drivers/video/sis/sis_main.c

   1 /*
   2  * SiS 300/305/540/630(S)/730(S)
   3  * SiS 315(H/PRO)/55x/(M)65x/(M)661(F/M)X/740/741(GX)/330/(M)760
   4  * frame buffer driver for Linux kernels >= 2.4.14 and >=2.6.3
   5  *
   6  * Copyright (C) 2001-2004 Thomas Winischhofer, Vienna, Austria.
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the named License,
  11  * or 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, MA 02111-1307, USA
  21  *
  22  * Author:      Thomas Winischhofer <thomas@winischhofer.net>
  23  *
  24  * Author of (practically wiped) code base:
  25  *              SiS (www.sis.com)
  26  *              Copyright (C) 1999 Silicon Integrated Systems, Inc.
  27  *
  28  * See http://www.winischhofer.net/ for more information and updates
  29  *
  30  * Originally based on the VBE 2.0 compliant graphic boards framebuffer driver,
  31  * which is (c) 1998 Gerd Knorr <kraxel@goldbach.in-berlin.de>
  32  *
  33  */
  34
  35 #include <linux/config.h>
  36 #include <linux/version.h>
  37 #include <linux/module.h>
  38 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)
  39 #include <linux/moduleparam.h>
  40 #endif
  41 #include <linux/kernel.h>
  42 #include <linux/spinlock.h>
  43 #include <linux/errno.h>
  44 #include <linux/string.h>
  45 #include <linux/mm.h>
  46 #include <linux/tty.h>
  47 #include <linux/slab.h>
  48 #include <linux/delay.h>
  49 #include <linux/fb.h>
  50 #include <linux/console.h>
  51 #include <linux/selection.h>
  52 #include <linux/ioport.h>
  53 #include <linux/init.h>
  54 #include <linux/pci.h>
  55 #include <linux/vmalloc.h>
  56 #include <linux/vt_kern.h>
  57 #include <linux/capability.h>
  58 #include <linux/fs.h>
  59 #include <linux/types.h>
  60 #include <asm/uaccess.h>
  61 #include <asm/io.h>
  62 #ifdef CONFIG_MTRR
  63 #include <asm/mtrr.h>
  64 #endif
  65
  66 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
  67 #include <video/fbcon.h>
  68 #include <video/fbcon-cfb8.h>
  69 #include <video/fbcon-cfb16.h>
  70 #include <video/fbcon-cfb24.h>
  71 #include <video/fbcon-cfb32.h>
  72 #endif
  73
  74 #include "sis.h"
  75 #include "sis_main.h"
  76
  77 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)
  78 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,3)
  79 #error "This version of sisfb requires at least 2.6.3"
  80 #endif
  81 #endif
  82
  83 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
  84 #ifdef FBCON_HAS_CFB8
  85 extern struct display_switch fbcon_sis8;
  86 #endif
  87 #ifdef FBCON_HAS_CFB16
  88 extern struct display_switch fbcon_sis16;
  89 #endif
  90 #ifdef FBCON_HAS_CFB32
  91 extern struct display_switch fbcon_sis32;
  92 #endif
  93 #endif
  94
  95 /* ------------------ Internal helper routines ----------------- */
  96
  97 static void __init
  98 sisfb_setdefaultparms(void)
  99 {
 100         sisfb_off               = 0;
 101         sisfb_parm_mem          = 0;
 102         sisfb_accel             = -1;
 103         sisfb_ypan              = -1;
 104         sisfb_max               = -1;
 105         sisfb_userom            = -1;
 106         sisfb_useoem            = -1;
 107 #ifdef MODULE
 108         /* Module: "None" for 2.4, default mode for 2.5+ */
 109 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)
 110         sisfb_mode_idx          = -1;
 111 #else
 112         sisfb_mode_idx          = MODE_INDEX_NONE;
 113 #endif
 114 #else
 115         /* Static: Default mode */
 116         sisfb_mode_idx          = -1;
 117 #endif
 118         sisfb_parm_rate         = -1;
 119         sisfb_crt1off           = 0;
 120         sisfb_forcecrt1         = -1;
 121         sisfb_crt2type          = -1;
 122         sisfb_crt2flags         = 0;
 123         sisfb_pdc               = 0xff;
 124         sisfb_pdca              = 0xff;
 125         sisfb_scalelcd          = -1;
 126         sisfb_specialtiming     = CUT_NONE;
 127         sisfb_lvdshl            = -1;
 128         sisfb_dstn              = 0;
 129         sisfb_fstn              = 0;
 130         sisfb_tvplug            = -1;
 131         sisfb_tvstd             = -1;
 132         sisfb_tvxposoffset      = 0;
 133         sisfb_tvyposoffset      = 0;
 134         sisfb_filter            = -1;
 135         sisfb_nocrt2rate        = 0;
 136 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
 137         sisfb_inverse           = 0;
 138         sisfb_fontname[0]       = 0;
 139 #endif
 140 #if !defined(__i386__) && !defined(__x86_64__)
 141         sisfb_resetcard         = 0;
 142         sisfb_videoram          = 0;
 143 #endif
 144 }
 145
 146 static void __init
 147 sisfb_search_vesamode(unsigned int vesamode, BOOLEAN quiet)
 148 {
 149         int i = 0, j = 0;
 150
 151         /* BEWARE: We don't know the hardware specs yet and there is no ivideo */
 152
 153         if(vesamode == 0) {
 154 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
 155                 sisfb_mode_idx = MODE_INDEX_NONE;
 156 #else
 157                 if(!quiet) {
 158                    printk(KERN_ERR "sisfb: Invalid mode. Using default.\n");
 159                 }
 160                 sisfb_mode_idx = DEFAULT_MODE;
 161 #endif
 162                 return;
 163         }
 164
 165         vesamode &= 0x1dff;  /* Clean VESA mode number from other flags */
 166
 167         while(sisbios_mode[i++].mode_no[0] != 0) {
 168                 if( (sisbios_mode[i-1].vesa_mode_no_1 == vesamode) ||
 169                     (sisbios_mode[i-1].vesa_mode_no_2 == vesamode) ) {
 170                     if(sisfb_fstn) {
 171                        if(sisbios_mode[i-1].mode_no[1] == 0x50 ||
 172                           sisbios_mode[i-1].mode_no[1] == 0x56 ||
 173                           sisbios_mode[i-1].mode_no[1] == 0x53) continue;
 174                     } else {
 175                        if(sisbios_mode[i-1].mode_no[1] == 0x5a ||
 176                           sisbios_mode[i-1].mode_no[1] == 0x5b) continue;
 177                     }
 178                     sisfb_mode_idx = i - 1;
 179                     j = 1;
 180                     break;
 181                 }
 182         }
 183         if((!j) && !quiet) printk(KERN_ERR "sisfb: Invalid VESA mode 0x%x'\n", vesamode);
 184 }
 185
 186 static void
 187 sisfb_search_mode(char *name, BOOLEAN quiet)
 188 {
 189         int i = 0;
 190         unsigned int j = 0, xres = 0, yres = 0, depth = 0, rate = 0;
 191         char strbuf[16], strbuf1[20];
 192         char *nameptr = name;
 193
 194         /* BEWARE: We don't know the hardware specs yet and there is no ivideo */
 195
 196         if(name == NULL) {
 197            if(!quiet) {
 198               printk(KERN_ERR "sisfb: Internal error, using default mode.\n");
 199            }
 200            sisfb_mode_idx = DEFAULT_MODE;
 201            return;
 202         }
 203
 204 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)
 205         if(!strnicmp(name, sisbios_mode[MODE_INDEX_NONE].name, strlen(name))) {
 206            if(!quiet) {
 207               printk(KERN_ERR "sisfb: Mode 'none' not supported anymore. Using default.\n");
 208            }
 209            sisfb_mode_idx = DEFAULT_MODE;
 210            return;
 211         }
 212 #endif
 213         if(strlen(name) <= 19) {
 214            strcpy(strbuf1, name);
 215            for(i=0; i<strlen(strbuf1); i++) {
 216               if(strbuf1[i] < '0' || strbuf1[i] > '9') strbuf1[i] = ' ';
 217            }
 218
 219            /* This does some fuzzy mode naming detection */
 220            if(sscanf(strbuf1, "%u %u %u %u", &xres, &yres, &depth, &rate) == 4) {
 221               if((rate <= 32) || (depth > 32)) {
 222                  j = rate; rate = depth; depth = j;
 223               }
 224               sprintf(strbuf, "%ux%ux%u", xres, yres, depth);
 225               nameptr = strbuf;
 226               sisfb_parm_rate = rate;
 227            } else if(sscanf(strbuf1, "%u %u %u", &xres, &yres, &depth) == 3) {
 228               sprintf(strbuf, "%ux%ux%u", xres, yres, depth);
 229               nameptr = strbuf;
 230            } else {
 231               xres = 0;
 232               if((sscanf(strbuf1, "%u %u", &xres, &yres) == 2) && (xres != 0)) {
 233                  sprintf(strbuf, "%ux%ux8", xres, yres);
 234                  nameptr = strbuf;
 235               } else {
 236                  sisfb_search_vesamode(simple_strtoul(name, NULL, 0), quiet);
 237                  return;
 238               }
 239            }
 240         }
 241
 242         i = 0; j = 0;
 243         while(sisbios_mode[i].mode_no[0] != 0) {
 244                 if(!strnicmp(nameptr, sisbios_mode[i++].name, strlen(nameptr))) {
 245                         if(sisfb_fstn) {
 246                                 if(sisbios_mode[i-1].mode_no[1] == 0x50 ||
 247                                    sisbios_mode[i-1].mode_no[1] == 0x56 ||
 248                                    sisbios_mode[i-1].mode_no[1] == 0x53) continue;
 249                         } else {
 250                                 if(sisbios_mode[i-1].mode_no[1] == 0x5a ||
 251                                    sisbios_mode[i-1].mode_no[1] == 0x5b) continue;
 252                         }
 253                         sisfb_mode_idx = i - 1;
 254                         j = 1;
 255                         break;
 256                 }
 257         }
 258         if((!j) && !quiet) printk(KERN_ERR "sisfb: Invalid mode '%s'\n", nameptr);
 259 }
 260
 261 #ifndef MODULE
 262 static void __devinit
 263 sisfb_get_vga_mode_from_kernel(void)
 264 {
 265 #if (defined(__i386__) || defined(__x86_64__)) && defined(CONFIG_VIDEO_SELECT)
 266         char mymode[32];
 267         int  mydepth = screen_info.lfb_depth;
 268
 269         if(screen_info.orig_video_isVGA != VIDEO_TYPE_VLFB) return;
 270
 271         if( (screen_info.lfb_width >= 320) && (screen_info.lfb_width <= 2048) &&
 272             (screen_info.lfb_height >= 200) && (screen_info.lfb_height <= 1536) &&
 273             (mydepth >= 8) && (mydepth <= 32) ) {
 274
 275             if(mydepth == 24) mydepth = 32;
 276
 277             sprintf(mymode, "%ux%ux%u", screen_info.lfb_width,
 278                                         screen_info.lfb_height,
 279                                         mydepth);
 280
 281             printk(KERN_DEBUG "sisfb: Using vga mode %s pre-set by kernel as default\n", mymode);
 282
 283             sisfb_search_mode(mymode, TRUE);
 284         }
 285 #endif
 286         return;
 287 }
 288 #endif
 289
 290 static void __init
 291 sisfb_search_crt2type(const char *name)
 292 {
 293         int i = 0;
 294
 295         /* BEWARE: We don't know the hardware specs yet and there is no ivideo */
 296
 297         if(name == NULL) return;
 298
 299         while(sis_crt2type[i].type_no != -1) {
 300                 if(!strnicmp(name, sis_crt2type[i].name, strlen(sis_crt2type[i].name))) {
 301                         sisfb_crt2type = sis_crt2type[i].type_no;
 302                         sisfb_tvplug = sis_crt2type[i].tvplug_no;
 303                         sisfb_crt2flags = sis_crt2type[i].flags;
 304                         break;
 305                 }
 306                 i++;
 307         }
 308
 309         sisfb_dstn = (sisfb_crt2flags & FL_550_DSTN) ? 1 : 0;
 310         sisfb_fstn = (sisfb_crt2flags & FL_550_FSTN) ? 1 : 0;
 311
 312         if(sisfb_crt2type < 0) {
 313                 printk(KERN_ERR "sisfb: Invalid CRT2 type: %s\n", name);
 314         }
 315 }
 316
 317 static void __init
 318 sisfb_search_tvstd(const char *name)
 319 {
 320         int i = 0;
 321
 322         /* BEWARE: We don't know the hardware specs yet and there is no ivideo */
 323
 324         if(name == NULL) return;
 325
 326         while(sis_tvtype[i].type_no != -1) {
 327                 if(!strnicmp(name, sis_tvtype[i].name, strlen(sis_tvtype[i].name))) {
 328                         sisfb_tvstd = sis_tvtype[i].type_no;
 329                         break;
 330                 }
 331                 i++;
 332         }
 333 }
 334
 335 static void __init
 336 sisfb_search_specialtiming(const char *name)
 337 {
 338         int i = 0;
 339         BOOLEAN found = FALSE;
 340
 341         /* BEWARE: We don't know the hardware specs yet and there is no ivideo */
 342
 343         if(name == NULL) return;
 344
 345         if(!strnicmp(name, "none", 4)) {
 346                 sisfb_specialtiming = CUT_FORCENONE;
 347                 printk(KERN_DEBUG "sisfb: Special timing disabled\n");
 348         } else {
 349            while(mycustomttable[i].chipID != 0) {
 350               if(!strnicmp(name,mycustomttable[i].optionName, strlen(mycustomttable[i].optionName))) {
 351                  sisfb_specialtiming = mycustomttable[i].SpecialID;
 352                  found = TRUE;
 353                  printk(KERN_INFO "sisfb: Special timing for %s %s forced (\"%s\")\n",
 354                         mycustomttable[i].vendorName, mycustomttable[i].cardName,
 355                         mycustomttable[i].optionName);
 356                  break;
 357               }
 358               i++;
 359            }
 360            if(!found) {
 361               printk(KERN_WARNING "sisfb: Invalid SpecialTiming parameter, valid are:");
 362               printk(KERN_WARNING "\t\"none\" (to disable special timings)\n");
 363               i = 0;
 364               while(mycustomttable[i].chipID != 0) {
 365                  printk(KERN_WARNING "\t\"%s\" (for %s %s)\n",
 366                      mycustomttable[i].optionName,
 367                      mycustomttable[i].vendorName,
 368                      mycustomttable[i].cardName);
 369                  i++;
 370               }
 371            }
 372         }
 373 }
 374
 375 static BOOLEAN __devinit
 376 sisfb_interpret_edid(struct sisfb_monitor *monitor, u8 *buffer)
 377 {
 378         int i, j, xres, yres, refresh, index;
 379         u32 emodes;
 380
 381         if(buffer[0] != 0x00 || buffer[1] != 0xff ||
 382            buffer[2] != 0xff || buffer[3] != 0xff ||
 383            buffer[4] != 0xff || buffer[5] != 0xff ||
 384            buffer[6] != 0xff || buffer[7] != 0x00) {
 385            printk(KERN_DEBUG "sisfb: Bad EDID header\n");
 386            return FALSE;
 387         }
 388
 389         if(buffer[0x12] != 0x01) {
 390            printk(KERN_INFO "sisfb: EDID version %d not supported\n",
 391                 buffer[0x12]);
 392            return FALSE;
 393         }
 394
 395         monitor->feature = buffer[0x18];
 396
 397         if(!buffer[0x14] & 0x80) {
 398            if(!(buffer[0x14] & 0x08)) {
 399               printk(KERN_INFO "sisfb: WARNING: Monitor does not support separate syncs\n");
 400            }
 401         }
 402
 403         if(buffer[0x13] >= 0x01) {
 404            /* EDID V1 rev 1 and 2: Search for monitor descriptor
 405             * to extract ranges
 406             */
 407             j = 0x36;
 408             for(i=0; i<4; i++) {
 409                if(buffer[j]     == 0x00 && buffer[j + 1] == 0x00 &&
 410                   buffer[j + 2] == 0x00 && buffer[j + 3] == 0xfd &&
 411                   buffer[j + 4] == 0x00) {
 412                   monitor->hmin = buffer[j + 7];
 413                   monitor->hmax = buffer[j + 8];
 414                   monitor->vmin = buffer[j + 5];
 415                   monitor->vmax = buffer[j + 6];
 416                   monitor->dclockmax = buffer[j + 9] * 10 * 1000;
 417                   monitor->datavalid = TRUE;
 418                   break;
 419                }
 420                j += 18;
 421             }
 422         }
 423
 424         if(!monitor->datavalid) {
 425            /* Otherwise: Get a range from the list of supported
 426             * Estabished Timings. This is not entirely accurate,
 427             * because fixed frequency monitors are not supported
 428             * that way.
 429             */
 430            monitor->hmin = 65535; monitor->hmax = 0;
 431            monitor->vmin = 65535; monitor->vmax = 0;
 432            monitor->dclockmax = 0;
 433            emodes = buffer[0x23] | (buffer[0x24] << 8) | (buffer[0x25] << 16);
 434            for(i = 0; i < 13; i++) {
 435               if(emodes & sisfb_ddcsmodes[i].mask) {
 436                  if(monitor->hmin > sisfb_ddcsmodes[i].h) monitor->hmin = sisfb_ddcsmodes[i].h;
 437                  if(monitor->hmax < sisfb_ddcsmodes[i].h) monitor->hmax = sisfb_ddcsmodes[i].h + 1;
 438                  if(monitor->vmin > sisfb_ddcsmodes[i].v) monitor->vmin = sisfb_ddcsmodes[i].v;
 439                  if(monitor->vmax < sisfb_ddcsmodes[i].v) monitor->vmax = sisfb_ddcsmodes[i].v;
 440                  if(monitor->dclockmax < sisfb_ddcsmodes[i].d) monitor->dclockmax = sisfb_ddcsmodes[i].d;
 441               }
 442            }
 443            index = 0x26;
 444            for(i = 0; i < 8; i++) {
 445               xres = (buffer[index] + 31) * 8;
 446               switch(buffer[index + 1] & 0xc0) {
 447                  case 0xc0: yres = (xres * 9) / 16; break;
 448                  case 0x80: yres = (xres * 4) /  5; break;
 449                  case 0x40: yres = (xres * 3) /  4; break;
 450                  default:   yres = xres;            break;
 451               }
 452               refresh = (buffer[index + 1] & 0x3f) + 60;
 453               if((xres >= 640) && (yres >= 480)) {
 454                  for(j = 0; j < 8; j++) {
 455                     if((xres == sisfb_ddcfmodes[j].x) &&
 456                        (yres == sisfb_ddcfmodes[j].y) &&
 457                        (refresh == sisfb_ddcfmodes[j].v)) {
 458                       if(monitor->hmin > sisfb_ddcfmodes[j].h) monitor->hmin = sisfb_ddcfmodes[j].h;
 459                       if(monitor->hmax < sisfb_ddcfmodes[j].h) monitor->hmax = sisfb_ddcfmodes[j].h + 1;
 460                       if(monitor->vmin > sisfb_ddcsmodes[j].v) monitor->vmin = sisfb_ddcsmodes[j].v;
 461                       if(monitor->vmax < sisfb_ddcsmodes[j].v) monitor->vmax = sisfb_ddcsmodes[j].v;
 462                       if(monitor->dclockmax < sisfb_ddcsmodes[j].d) monitor->dclockmax = sisfb_ddcsmodes[i].d;
 463                     }
 464                  }
 465               }
 466               index += 2;
 467            }
 468            if((monitor->hmin <= monitor->hmax) && (monitor->vmin <= monitor->vmax)) {
 469               monitor->datavalid = TRUE;
 470            }
 471         }
 472
 473         return(monitor->datavalid);
 474 }
 475
 476 static void __devinit
 477 sisfb_handle_ddc(struct sis_video_info *ivideo, struct sisfb_monitor *monitor, int crtno)
 478 {
 479         USHORT  temp, i, realcrtno = crtno;
 480         u8      buffer[256];
 481
 482         monitor->datavalid = FALSE;
 483
 484         if(crtno) {
 485            if(ivideo->vbflags & CRT2_LCD)      realcrtno = 1;
 486            else if(ivideo->vbflags & CRT2_VGA) realcrtno = 2;
 487            else return;
 488         }
 489
 490         if((ivideo->sisfb_crt1off) && (!crtno)) return;
 491
 492         temp = SiS_HandleDDC(&ivideo->SiS_Pr, ivideo->vbflags, ivideo->sisvga_engine,
 493                                 realcrtno, 0, &buffer[0]);
 494         if((!temp) || (temp == 0xffff)) {
 495            printk(KERN_INFO "sisfb: CRT%d DDC probing failed\n", crtno + 1);
 496            return;
 497         } else {
 498            printk(KERN_INFO "sisfb: CRT%d DDC supported\n", crtno + 1);
 499            printk(KERN_INFO "sisfb: CRT%d DDC level: %s%s%s%s\n",
 500                 crtno + 1,
 501                 (temp & 0x1a) ? "" : "[none of the supported]",
 502                 (temp & 0x02) ? "2 " : "",
 503                 (temp & 0x08) ? "D&P" : "",
 504                 (temp & 0x10) ? "FPDI-2" : "");
 505            if(temp & 0x02) {
 506               i = 3;  /* Number of retrys */
 507               do {
 508                  temp = SiS_HandleDDC(&ivideo->SiS_Pr, ivideo->vbflags, ivideo->sisvga_engine,
 509                                      realcrtno, 1, &buffer[0]);
 510               } while((temp) && i--);
 511               if(!temp) {
 512                  if(sisfb_interpret_edid(monitor, &buffer[0])) {
 513                     printk(KERN_INFO "sisfb: Monitor range H %d-%dKHz, V %d-%dHz, Max. dotclock %dMHz\n",
 514                         monitor->hmin, monitor->hmax, monitor->vmin, monitor->vmax,
 515                         monitor->dclockmax / 1000);
 516                  } else {
 517                     printk(KERN_INFO "sisfb: CRT%d DDC EDID corrupt\n", crtno + 1);
 518                  }
 519               } else {
 520                  printk(KERN_INFO "sisfb: CRT%d DDC reading failed\n", crtno + 1);
 521               }
 522            } else {
 523               printk(KERN_INFO "sisfb: VESA D&P and FPDI-2 not supported yet\n");
 524            }
 525         }
 526 }
 527
 528 static BOOLEAN
 529 sisfb_verify_rate(struct sis_video_info *ivideo, struct sisfb_monitor *monitor,
 530                 int mode_idx, int rate_idx, int rate)
 531 {
 532         int htotal, vtotal;
 533         unsigned int dclock, hsync;
 534
 535         if(!monitor->datavalid) return TRUE;
 536
 537         if(mode_idx < 0) return FALSE;
 538
 539         /* Skip for 320x200, 320x240, 640x400 */
 540         switch(sisbios_mode[mode_idx].mode_no[ivideo->mni]) {
 541         case 0x59:
 542         case 0x41:
 543         case 0x4f:
 544         case 0x50:
 545         case 0x56:
 546         case 0x53:
 547         case 0x2f:
 548         case 0x5d:
 549         case 0x5e:
 550                 return TRUE;
 551 #ifdef CONFIG_FB_SIS_315
 552         case 0x5a:
 553         case 0x5b:
 554                 if(ivideo->sisvga_engine == SIS_315_VGA) return TRUE;
 555 #endif
 556         }
 557
 558         if(rate < (monitor->vmin - 1)) return FALSE;
 559         if(rate > (monitor->vmax + 1)) return FALSE;
 560
 561         if(sisfb_gettotalfrommode(&ivideo->SiS_Pr, &ivideo->sishw_ext,
 562                                   sisbios_mode[mode_idx].mode_no[ivideo->mni],
 563                                   &htotal, &vtotal, rate_idx)) {
 564                 dclock = (htotal * vtotal * rate) / 1000;
 565                 if(dclock > (monitor->dclockmax + 1000)) return FALSE;
 566                 hsync = dclock / htotal;
 567                 if(hsync < (monitor->hmin - 1)) return FALSE;
 568                 if(hsync > (monitor->hmax + 1)) return FALSE;
 569         } else {
 570                 return FALSE;
 571         }
 572         return TRUE;
 573 }
 574
 575 static int
 576 sisfb_validate_mode(struct sis_video_info *ivideo, int myindex, u32 vbflags)
 577 {
 578    u16 xres=0, yres, myres;
 579
 580 #ifdef CONFIG_FB_SIS_300
 581    if(ivideo->sisvga_engine == SIS_300_VGA) {
 582       if(!(sisbios_mode[myindex].chipset & MD_SIS300)) return(-1);
 583    }
 584 #endif
 585 #ifdef CONFIG_FB_SIS_315
 586    if(ivideo->sisvga_engine == SIS_315_VGA) {
 587       if(!(sisbios_mode[myindex].chipset & MD_SIS315)) return(-1);
 588    }
 589 #endif
 590
 591    myres = sisbios_mode[myindex].yres;
 592
 593    switch(vbflags & VB_DISPTYPE_DISP2) {
 594
 595      case CRT2_LCD:
 596
 597         xres = ivideo->lcdxres; yres = ivideo->lcdyres;
 598
 599         if(ivideo->SiS_Pr.SiS_CustomT != CUT_PANEL848) {
 600                 if(sisbios_mode[myindex].xres > xres) return(-1);
 601                 if(myres > yres) return(-1);
 602         }
 603
 604         if(vbflags & (VB_LVDS | VB_30xBDH)) {
 605            if(sisbios_mode[myindex].xres == 320) {
 606               if((myres == 240) || (myres == 480)) {
 607                  if(!ivideo->sisfb_fstn) {
 608                     if(sisbios_mode[myindex].mode_no[1] == 0x5a ||
 609                        sisbios_mode[myindex].mode_no[1] == 0x5b)
 610                        return(-1);
 611                  } else {
 612                     if(sisbios_mode[myindex].mode_no[1] == 0x50 ||
 613                        sisbios_mode[myindex].mode_no[1] == 0x56 ||
 614                        sisbios_mode[myindex].mode_no[1] == 0x53)
 615                        return(-1);
 616                  }
 617               }
 618            }
 619         }
 620
 621         if(SiS_GetModeID_LCD(ivideo->sisvga_engine, vbflags, sisbios_mode[myindex].xres,
 622                              sisbios_mode[myindex].yres, 0, ivideo->sisfb_fstn,
 623                              ivideo->SiS_Pr.SiS_CustomT, xres, yres) < 0x14) {
 624                 return(-1);
 625         }
 626         break;
 627
 628      case CRT2_TV:
 629         if(SiS_GetModeID_TV(ivideo->sisvga_engine, vbflags, sisbios_mode[myindex].xres,
 630                             sisbios_mode[myindex].yres, 0) < 0x14) {
 631                 return(-1);
 632         }
 633         break;
 634
 635      case CRT2_VGA:
 636         if(SiS_GetModeID_VGA2(ivideo->sisvga_engine, vbflags, sisbios_mode[myindex].xres,
 637                               sisbios_mode[myindex].yres, 0) < 0x14) {
 638                 return(-1);
 639         }
 640         break;
 641      }
 642
 643      return(myindex);
 644 }
 645
 646 static u8
 647 sisfb_search_refresh_rate(struct sis_video_info *ivideo, unsigned int rate, int mode_idx)
 648 {
 649         u16 xres, yres;
 650         int i = 0;
 651
 652         xres = sisbios_mode[mode_idx].xres;
 653         yres = sisbios_mode[mode_idx].yres;
 654
 655         ivideo->rate_idx = 0;
 656         while((sisfb_vrate[i].idx != 0) && (sisfb_vrate[i].xres <= xres)) {
 657                 if((sisfb_vrate[i].xres == xres) && (sisfb_vrate[i].yres == yres)) {
 658                         if(sisfb_vrate[i].refresh == rate) {
 659                                 ivideo->rate_idx = sisfb_vrate[i].idx;
 660                                 break;
 661                         } else if(sisfb_vrate[i].refresh > rate) {
 662                                 if((sisfb_vrate[i].refresh - rate) <= 3) {
 663                                         DPRINTK("sisfb: Adjusting rate from %d up to %d\n",
 664                                                 rate, sisfb_vrate[i].refresh);
 665                                         ivideo->rate_idx = sisfb_vrate[i].idx;
 666                                         ivideo->refresh_rate = sisfb_vrate[i].refresh;
 667                                 } else if(((rate - sisfb_vrate[i-1].refresh) <= 2)
 668                                                 && (sisfb_vrate[i].idx != 1)) {
 669                                         DPRINTK("sisfb: Adjusting rate from %d down to %d\n",
 670                                                 rate, sisfb_vrate[i-1].refresh);
 671                                         ivideo->rate_idx = sisfb_vrate[i-1].idx;
 672                                         ivideo->refresh_rate = sisfb_vrate[i-1].refresh;
 673                                 }
 674                                 break;
 675                         } else if((rate - sisfb_vrate[i].refresh) <= 2) {
 676                                 DPRINTK("sisfb: Adjusting rate from %d down to %d\n",
 677                                                 rate, sisfb_vrate[i].refresh);
 678                                 ivideo->rate_idx = sisfb_vrate[i].idx;
 679                                 break;
 680                         }
 681                 }
 682                 i++;
 683         }
 684         if(ivideo->rate_idx > 0) {
 685                 return ivideo->rate_idx;
 686         } else {
 687                 printk(KERN_INFO "sisfb: Unsupported rate %d for %dx%d\n",
 688                                 rate, xres, yres);
 689                 return 0;
 690         }
 691 }
 692
 693 static BOOLEAN
 694 sisfb_bridgeisslave(struct sis_video_info *ivideo)
 695 {
 696    unsigned char P1_00;
 697
 698    if(!(ivideo->vbflags & VB_VIDEOBRIDGE)) return FALSE;
 699
 700    inSISIDXREG(SISPART1,0x00,P1_00);
 701    if( ((ivideo->sisvga_engine == SIS_300_VGA) && (P1_00 & 0xa0) == 0x20) ||
 702        ((ivideo->sisvga_engine == SIS_315_VGA) && (P1_00 & 0x50) == 0x10) ) {
 703            return TRUE;
 704    } else {
 705            return FALSE;
 706    }
 707 }
 708
 709 static BOOLEAN
 710 sisfballowretracecrt1(struct sis_video_info *ivideo)
 711 {
 712    u8 temp;
 713
 714    inSISIDXREG(SISCR,0x17,temp);
 715    if(!(temp & 0x80)) return FALSE;
 716
 717    inSISIDXREG(SISSR,0x1f,temp);
 718    if(temp & 0xc0) return FALSE;
 719
 720    return TRUE;
 721 }
 722
 723 static BOOLEAN
 724 sisfbcheckvretracecrt1(struct sis_video_info *ivideo)
 725 {
 726    if(!sisfballowretracecrt1(ivideo)) return FALSE;
 727
 728    if(inSISREG(SISINPSTAT) & 0x08) return TRUE;
 729    else                            return FALSE;
 730 }
 731
 732 static void
 733 sisfbwaitretracecrt1(struct sis_video_info *ivideo)
 734 {
 735    int watchdog;
 736
 737    if(!sisfballowretracecrt1(ivideo)) return;
 738
 739    watchdog = 65536;
 740    while((!(inSISREG(SISINPSTAT) & 0x08)) && --watchdog);
 741    watchdog = 65536;
 742    while((inSISREG(SISINPSTAT) & 0x08) && --watchdog);
 743 }
 744
 745 static BOOLEAN
 746 sisfbcheckvretracecrt2(struct sis_video_info *ivideo)
 747 {
 748    unsigned char temp, reg;
 749
 750    switch(ivideo->sisvga_engine) {
 751    case SIS_300_VGA: reg = 0x25; break;
 752    case SIS_315_VGA: reg = 0x30; break;
 753    default:          return FALSE;
 754    }
 755
 756    inSISIDXREG(SISPART1, reg, temp);
 757    if(temp & 0x02) return FALSE;
 758    else            return TRUE;
 759 }
 760
 761 static BOOLEAN
 762 sisfb_CheckVBRetrace(struct sis_video_info *ivideo)
 763 {
 764    if(ivideo->currentvbflags & VB_DISPTYPE_DISP2) {
 765       if(sisfb_bridgeisslave(ivideo)) {
 766          return(sisfbcheckvretracecrt1(ivideo));
 767       } else {
 768          return(sisfbcheckvretracecrt2(ivideo));
 769       }
 770    }
 771    return(sisfbcheckvretracecrt1(ivideo));
 772 }
 773
 774 static u32
 775 sisfb_setupvbblankflags(struct sis_video_info *ivideo, u32 *vcount, u32 *hcount)
 776 {
 777    u8 idx, reg1, reg2, reg3, reg4;
 778    u32 ret = 0;
 779
 780    (*vcount) = (*hcount) = 0;
 781
 782    if((ivideo->currentvbflags & VB_DISPTYPE_DISP2) && (!(sisfb_bridgeisslave(ivideo)))) {
 783       ret |= (FB_VBLANK_HAVE_VSYNC  |
 784               FB_VBLANK_HAVE_HBLANK |
 785               FB_VBLANK_HAVE_VBLANK |
 786               FB_VBLANK_HAVE_VCOUNT |
 787               FB_VBLANK_HAVE_HCOUNT);
 788       switch(ivideo->sisvga_engine) {
 789          case SIS_300_VGA: idx = 0x25; break;
 790          default:
 791          case SIS_315_VGA: idx = 0x30; break;
 792       }
 793       inSISIDXREG(SISPART1,(idx+0),reg1); /* 30 */
 794       inSISIDXREG(SISPART1,(idx+1),reg2); /* 31 */
 795       inSISIDXREG(SISPART1,(idx+2),reg3); /* 32 */
 796       inSISIDXREG(SISPART1,(idx+3),reg4); /* 33 */
 797       if(!(reg1 & 0x01)) ret |= FB_VBLANK_VBLANKING;
 798       if(!(reg1 & 0x02)) ret |= FB_VBLANK_VSYNCING;
 799       if(!(reg4 & 0x80)) ret |= FB_VBLANK_HBLANKING;
 800       (*vcount) = reg3 | ((reg4 & 0x70) << 4);
 801       (*hcount) = reg2 | ((reg4 & 0x0f) << 8);
 802    } else if(sisfballowretracecrt1(ivideo)) {
 803       ret |= (FB_VBLANK_HAVE_VSYNC  |
 804               FB_VBLANK_HAVE_VBLANK |
 805               FB_VBLANK_HAVE_VCOUNT |
 806               FB_VBLANK_HAVE_HCOUNT);
 807       reg1 = inSISREG(SISINPSTAT);
 808       if(reg1 & 0x08) ret |= FB_VBLANK_VSYNCING;
 809       if(reg1 & 0x01) ret |= FB_VBLANK_VBLANKING;
 810       inSISIDXREG(SISCR,0x20,reg1);
 811       inSISIDXREG(SISCR,0x1b,reg1);
 812       inSISIDXREG(SISCR,0x1c,reg2);
 813       inSISIDXREG(SISCR,0x1d,reg3);
 814       (*vcount) = reg2 | ((reg3 & 0x07) << 8);
 815       (*hcount) = (reg1 | ((reg3 & 0x10) << 4)) << 3;
 816    }
 817    return ret;
 818 }
 819
 820 static int
 821 sisfb_myblank(struct sis_video_info *ivideo, int blank)
 822 {
 823    u8 sr01, sr11, sr1f, cr63=0, p2_0, p1_13;
 824    BOOLEAN backlight = TRUE;
 825
 826    switch(blank) {
 827    case 0:      /* on */
 828       sr01  = 0x00;
 829       sr11  = 0x00;
 830       sr1f  = 0x00;
 831       cr63  = 0x00;
 832       p2_0  = 0x20;
 833       p1_13 = 0x00;
 834       backlight = TRUE;
 835       break;
 836    case 1:      /* blank */
 837       sr01  = 0x20;
 838       sr11  = 0x00;
 839       sr1f  = 0x00;
 840       cr63  = 0x00;
 841       p2_0  = 0x20;
 842       p1_13 = 0x00;
 843       backlight = TRUE;
 844       break;
 845    case 2:      /* no vsync */
 846       sr01  = 0x20;
 847       sr11  = 0x08;
 848       sr1f  = 0x80;
 849       cr63  = 0x40;
 850       p2_0  = 0x40;
 851       p1_13 = 0x80;
 852       backlight = FALSE;
 853       break;
 854    case 3:      /* no hsync */
 855       sr01  = 0x20;
 856       sr11  = 0x08;
 857       sr1f  = 0x40;
 858       cr63  = 0x40;
 859       p2_0  = 0x80;
 860       p1_13 = 0x40;
 861       backlight = FALSE;
 862       break;
 863    case 4:      /* off */
 864       sr01  = 0x20;
 865       sr11  = 0x08;
 866       sr1f  = 0xc0;
 867       cr63  = 0x40;
 868       p2_0  = 0xc0;
 869       p1_13 = 0xc0;
 870       backlight = FALSE;
 871       break;
 872    default:
 873       return 1;
 874    }
 875
 876    if(ivideo->currentvbflags & VB_DISPTYPE_CRT1) {
 877
 878       if( (!ivideo->sisfb_thismonitor.datavalid) ||
 879           ((ivideo->sisfb_thismonitor.datavalid) &&
 880            (ivideo->sisfb_thismonitor.feature & 0xe0))) {
 881
 882          if(ivideo->sisvga_engine == SIS_315_VGA) {
 883             setSISIDXREG(SISCR, ivideo->SiS_Pr.SiS_MyCR63, 0xbf, cr63);
 884          }
 885
 886          if(!(sisfb_bridgeisslave(ivideo))) {
 887             setSISIDXREG(SISSR, 0x01, ~0x20, sr01);
 888             setSISIDXREG(SISSR, 0x1f, 0x3f, sr1f);
 889          }
 890       }
 891
 892    }
 893
 894    if(ivideo->currentvbflags & CRT2_LCD) {
 895
 896       if(ivideo->vbflags & (VB_301LV|VB_302LV|VB_302ELV)) {
 897          if(backlight) {
 898             SiS_SiS30xBLOn(&ivideo->SiS_Pr, &ivideo->sishw_ext);
 899          } else {
 900             SiS_SiS30xBLOff(&ivideo->SiS_Pr, &ivideo->sishw_ext);
 901          }
 902       } else if(ivideo->sisvga_engine == SIS_315_VGA) {
 903          if(ivideo->vbflags & VB_CHRONTEL) {
 904             if(backlight) {
 905                SiS_Chrontel701xBLOn(&ivideo->SiS_Pr,&ivideo->sishw_ext);
 906             } else {
 907                SiS_Chrontel701xBLOff(&ivideo->SiS_Pr);
 908             }
 909          }
 910       }
 911
 912       if(((ivideo->sisvga_engine == SIS_300_VGA) &&
 913           (ivideo->vbflags & (VB_301|VB_30xBDH|VB_LVDS))) ||
 914          ((ivideo->sisvga_engine == SIS_315_VGA) &&
 915           ((ivideo->vbflags & (VB_LVDS | VB_CHRONTEL)) == VB_LVDS))) {
 916           setSISIDXREG(SISSR, 0x11, ~0x0c, sr11);
 917       }
 918
 919       if(ivideo->sisvga_engine == SIS_300_VGA) {
 920          if((ivideo->vbflags & (VB_301B|VB_301C|VB_302B)) &&
 921             (!(ivideo->vbflags & VB_30xBDH))) {
 922             setSISIDXREG(SISPART1, 0x13, 0x3f, p1_13);
 923          }
 924       } else if(ivideo->sisvga_engine == SIS_315_VGA) {
 925          if((ivideo->vbflags & (VB_301B|VB_301C|VB_302B)) &&
 926             (!(ivideo->vbflags & VB_30xBDH))) {
 927             setSISIDXREG(SISPART2, 0x00, 0x1f, p2_0);
 928          }
 929       }
 930
 931    } else if(ivideo->currentvbflags & CRT2_VGA) {
 932
 933       if(ivideo->vbflags & (VB_301B|VB_301C|VB_302B)) {
 934          setSISIDXREG(SISPART2, 0x00, 0x1f, p2_0);
 935       }
 936
 937    }
 938
 939    return(0);
 940 }
 941
 942 /* ----------- FBDev related routines for all series ----------- */
 943
 944 static int
 945 sisfb_get_cmap_len(const struct fb_var_screeninfo *var)
 946 {
 947         return (var->bits_per_pixel == 8) ? 256 : 16;
 948 }
 949
 950 static void
 951 sisfb_set_vparms(struct sis_video_info *ivideo)
 952 {
 953         switch(ivideo->video_bpp) {
 954         case 8:
 955                 ivideo->DstColor = 0x0000;
 956                 ivideo->SiS310_AccelDepth = 0x00000000;
 957                 ivideo->video_cmap_len = 256;
 958                 break;
 959         case 16:
 960                 ivideo->DstColor = 0x8000;
 961                 ivideo->SiS310_AccelDepth = 0x00010000;
 962                 ivideo->video_cmap_len = 16;
 963                 break;
 964         case 32:
 965                 ivideo->DstColor = 0xC000;
 966                 ivideo->SiS310_AccelDepth = 0x00020000;
 967                 ivideo->video_cmap_len = 16;
 968                 break;
 969         default:
 970                 ivideo->video_cmap_len = 16;
 971                 printk(KERN_ERR "sisfb: Unsupported depth %d", ivideo->video_bpp);
 972                 ivideo->accel = 0;
 973                 break;
 974         }
 975 }
 976
 977 static int
 978 sisfb_calc_maxyres(struct sis_video_info *ivideo, struct fb_var_screeninfo *var)
 979 {
 980         int maxyres = ivideo->heapstart / (var->xres_virtual * (var->bits_per_pixel >> 3));
 981
 982         if(maxyres > 32767) maxyres = 32767;
 983
 984         return maxyres;
 985 }
 986
 987 static void
 988 sisfb_calc_pitch(struct sis_video_info *ivideo, struct fb_var_screeninfo *var)
 989 {
 990         ivideo->video_linelength = var->xres_virtual * (var->bits_per_pixel >> 3);
 991         ivideo->scrnpitchCRT1 = ivideo->video_linelength;
 992         if(!(ivideo->currentvbflags & CRT1_LCDA)) {
 993                 if((var->vmode & FB_VMODE_MASK) == FB_VMODE_INTERLACED) {
 994                         ivideo->scrnpitchCRT1 <<= 1;
 995                 }
 996         }
 997
 998 }
 999
1000 static void
1001 sisfb_set_pitch(struct sis_video_info *ivideo)
1002 {
1003         BOOLEAN isslavemode = FALSE;
1004         unsigned short HDisplay1 = ivideo->scrnpitchCRT1 >> 3;
1005         unsigned short HDisplay2 = ivideo->video_linelength >> 3;
1006
1007         if(sisfb_bridgeisslave(ivideo)) isslavemode = TRUE;
1008
1009         /* We need to set pitch for CRT1 if bridge is in slave mode, too */
1010         if((ivideo->currentvbflags & VB_DISPTYPE_DISP1) || (isslavemode)) {
1011                 outSISIDXREG(SISCR,0x13,(HDisplay1 & 0xFF));
1012                 setSISIDXREG(SISSR,0x0E,0xF0,(HDisplay1 >> 8));
1013         }
1014
1015         /* We must not set the pitch for CRT2 if bridge is in slave mode */
1016         if((ivideo->currentvbflags & VB_DISPTYPE_DISP2) && (!isslavemode)) {
1017                 orSISIDXREG(SISPART1,ivideo->CRT2_write_enable,0x01);
1018                 outSISIDXREG(SISPART1,0x07,(HDisplay2 & 0xFF));
1019                 setSISIDXREG(SISPART1,0x09,0xF0,(HDisplay2 >> 8));
1020         }
1021 }
1022
1023 static void
1024 sisfb_bpp_to_var(struct sis_video_info *ivideo, struct fb_var_screeninfo *var)
1025 {
1026         ivideo->video_cmap_len = sisfb_get_cmap_len(var);
1027
1028         switch(var->bits_per_pixel) {
1029         case 8:
1030                 var->red.offset = var->green.offset = var->blue.offset = 0;
1031                 var->red.length = var->green.length = var->blue.length = 6;
1032                 break;
1033         case 16:
1034                 var->red.offset = 11;
1035                 var->red.length = 5;
1036                 var->green.offset = 5;
1037                 var->green.length = 6;
1038                 var->blue.offset = 0;
1039                 var->blue.length = 5;
1040                 var->transp.offset = 0;
1041                 var->transp.length = 0;
1042                 break;
1043         case 32:
1044                 var->red.offset = 16;
1045                 var->red.length = 8;
1046                 var->green.offset = 8;
1047                 var->green.length = 8;
1048                 var->blue.offset = 0;
1049                 var->blue.length = 8;
1050                 var->transp.offset = 24;
1051                 var->transp.length = 8;
1052                 break;
1053         }
1054 }
1055
1056 static int
1057 sisfb_do_set_var(struct fb_var_screeninfo *var, int isactive, struct fb_info *info)
1058 {
1059         struct sis_video_info *ivideo = (struct sis_video_info *)info->par;
1060         unsigned int htotal = 0, vtotal = 0;
1061         unsigned int drate = 0, hrate = 0;
1062         int found_mode = 0;
1063         int old_mode;
1064         u32 pixclock;
1065
1066         htotal = var->left_margin + var->xres + var->right_margin + var->hsync_len;
1067
1068         vtotal = var->upper_margin + var->lower_margin + var->vsync_len;
1069
1070         pixclock = var->pixclock;
1071
1072         if((var->vmode & FB_VMODE_MASK) == FB_VMODE_NONINTERLACED) {
1073                 vtotal += var->yres;
1074                 vtotal <<= 1;
1075         } else if((var->vmode & FB_VMODE_MASK) == FB_VMODE_DOUBLE) {
1076                 vtotal += var->yres;
1077                 vtotal <<= 2;
1078         } else if((var->vmode & FB_VMODE_MASK) == FB_VMODE_INTERLACED) {
1079                 vtotal += var->yres;
1080                 vtotal <<= 1;
1081         } else  vtotal += var->yres;
1082
1083         if(!(htotal) || !(vtotal)) {
1084                 DPRINTK("sisfb: Invalid 'var' information\n");
1085                 return -EINVAL;
1086         }
1087
1088         if(pixclock && htotal && vtotal) {
1089                 drate = 1000000000 / pixclock;
1090                 hrate = (drate * 1000) / htotal;
1091                 ivideo->refresh_rate = (unsigned int) (hrate * 2 / vtotal);
1092         } else {
1093                 ivideo->refresh_rate = 60;
1094         }
1095
1096         old_mode = ivideo->sisfb_mode_idx;
1097         ivideo->sisfb_mode_idx = 0;
1098
1099         while( (sisbios_mode[ivideo->sisfb_mode_idx].mode_no[0] != 0) &&
1100                (sisbios_mode[ivideo->sisfb_mode_idx].xres <= var->xres) ) {
1101                 if( (sisbios_mode[ivideo->sisfb_mode_idx].xres == var->xres) &&
1102                     (sisbios_mode[ivideo->sisfb_mode_idx].yres == var->yres) &&
1103                     (sisbios_mode[ivideo->sisfb_mode_idx].bpp == var->bits_per_pixel)) {
1104                         ivideo->mode_no = sisbios_mode[ivideo->sisfb_mode_idx].mode_no[ivideo->mni];
1105                         found_mode = 1;
1106                         break;
1107                 }
1108                 ivideo->sisfb_mode_idx++;
1109         }
1110
1111         if(found_mode) {
1112                 ivideo->sisfb_mode_idx = sisfb_validate_mode(ivideo,
1113                                 ivideo->sisfb_mode_idx, ivideo->currentvbflags);
1114         } else {
1115                 ivideo->sisfb_mode_idx = -1;
1116         }
1117
1118         if(ivideo->sisfb_mode_idx < 0) {
1119                 printk(KERN_ERR "sisfb: Mode %dx%dx%d not supported\n", var->xres,
1120                        var->yres, var->bits_per_pixel);
1121                 ivideo->sisfb_mode_idx = old_mode;
1122                 return -EINVAL;
1123         }
1124
1125         if(sisfb_search_refresh_rate(ivideo, ivideo->refresh_rate, ivideo->sisfb_mode_idx) == 0) {
1126                 ivideo->rate_idx = sisbios_mode[ivideo->sisfb_mode_idx].rate_idx;
1127                 ivideo->refresh_rate = 60;
1128         }
1129
1130 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
1131         if(ivideo->sisfb_thismonitor.datavalid) {
1132            if(!sisfb_verify_rate(ivideo, &ivideo->sisfb_thismonitor, ivideo->sisfb_mode_idx,
1133                                  ivideo->rate_idx, ivideo->refresh_rate)) {
1134               printk(KERN_INFO "sisfb: WARNING: Refresh rate exceeds monitor specs!\n");
1135            }
1136         }
1137 #endif
1138
1139 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
1140         if(((var->activate & FB_ACTIVATE_MASK) == FB_ACTIVATE_NOW) && isactive) {
1141 #else
1142         if(isactive) {
1143 #endif
1144                 sisfb_pre_setmode(ivideo);
1145
1146                 if(SiSSetMode(&ivideo->SiS_Pr, &ivideo->sishw_ext, ivideo->mode_no) == 0) {
1147                         printk(KERN_ERR "sisfb: Setting mode[0x%x] failed\n", ivideo->mode_no);
1148                         return -EINVAL;
1149                 }
1150
1151                 outSISIDXREG(SISSR, IND_SIS_PASSWORD, SIS_PASSWORD);
1152
1153                 sisfb_post_setmode(ivideo);
1154
1155                 ivideo->video_bpp    = sisbios_mode[ivideo->sisfb_mode_idx].bpp;
1156                 ivideo->video_width  = sisbios_mode[ivideo->sisfb_mode_idx].xres;
1157                 ivideo->video_height = sisbios_mode[ivideo->sisfb_mode_idx].yres;
1158
1159                 sisfb_calc_pitch(ivideo, var);
1160                 sisfb_set_pitch(ivideo);
1161
1162                 ivideo->accel = 0;
1163 #if defined(FBINFO_HWACCEL_DISABLED) && defined(FBINFO_HWACCEL_XPAN)
1164 #ifdef STUPID_ACCELF_TEXT_SHIT
1165                 if(var->accel_flags & FB_ACCELF_TEXT) {
1166                         info->flags &= ~FBINFO_HWACCEL_DISABLED;
1167                 } else {
1168                         info->flags |= FBINFO_HWACCEL_DISABLED;
1169                 }
1170 #endif
1171                 if(!(info->flags & FBINFO_HWACCEL_DISABLED)) ivideo->accel = -1;
1172 #else
1173                 if(var->accel_flags & FB_ACCELF_TEXT) ivideo->accel = -1;
1174 #endif
1175
1176                 sisfb_set_vparms(ivideo);
1177
1178                 ivideo->current_width = ivideo->video_width;
1179                 ivideo->current_height = ivideo->video_height;
1180                 ivideo->current_bpp = ivideo->video_bpp;
1181                 ivideo->current_htotal = htotal;
1182                 ivideo->current_vtotal = vtotal;
1183                 ivideo->current_linelength = ivideo->video_linelength;
1184                 ivideo->current_pixclock = var->pixclock;
1185                 ivideo->current_refresh_rate = ivideo->refresh_rate;
1186 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)
1187                 ivideo->sisfb_lastrates[ivideo->mode_no] = ivideo->refresh_rate;
1188 #endif
1189         }
1190
1191         return 0;
1192 }
1193
1194 static int
1195 sisfb_pan_var(struct sis_video_info *ivideo, struct fb_var_screeninfo *var)
1196 {
1197         unsigned int base;
1198
1199         if(var->xoffset > (var->xres_virtual - var->xres)) {
1200                 return -EINVAL;
1201         }
1202         if(var->yoffset > (var->yres_virtual - var->yres)) {
1203                 return -EINVAL;
1204         }
1205
1206         base = (var->yoffset * var->xres_virtual) + var->xoffset;
1207
1208         /* calculate base bpp dep. */
1209         switch(var->bits_per_pixel) {
1210         case 32:
1211                 break;
1212         case 16:
1213                 base >>= 1;
1214                 break;
1215         case 8:
1216         default:
1217                 base >>= 2;
1218                 break;
1219         }
1220
1221         outSISIDXREG(SISSR, IND_SIS_PASSWORD, SIS_PASSWORD);
1222
1223         outSISIDXREG(SISCR, 0x0D, base & 0xFF);
1224         outSISIDXREG(SISCR, 0x0C, (base >> 8) & 0xFF);
1225         outSISIDXREG(SISSR, 0x0D, (base >> 16) & 0xFF);
1226         if(ivideo->sisvga_engine == SIS_315_VGA) {
1227                 setSISIDXREG(SISSR, 0x37, 0xFE, (base >> 24) & 0x01);
1228         }
1229         if(ivideo->currentvbflags & VB_DISPTYPE_DISP2) {
1230                 orSISIDXREG(SISPART1, ivideo->CRT2_write_enable, 0x01);
1231                 outSISIDXREG(SISPART1, 0x06, (base & 0xFF));
1232                 outSISIDXREG(SISPART1, 0x05, ((base >> 8) & 0xFF));
1233                 outSISIDXREG(SISPART1, 0x04, ((base >> 16) & 0xFF));
1234                 if(ivideo->sisvga_engine == SIS_315_VGA) {
1235                         setSISIDXREG(SISPART1, 0x02, 0x7F, ((base >> 24) & 0x01) << 7);
1236                 }
1237         }
1238         return 0;
1239 }
1240
1241 /* ------------ FBDev related routines for 2.4 series ----------- */
1242
1243 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
1244
1245 static void
1246 sisfb_crtc_to_var(struct sis_video_info *ivideo, struct fb_var_screeninfo *var)
1247 {
1248         u16 VRE, VBE, VRS, VBS, VDE, VT;
1249         u16 HRE, HBE, HRS, HBS, HDE, HT;
1250         u8  sr_data, cr_data, cr_data2, cr_data3, mr_data;
1251         int A, B, C, D, E, F, temp;
1252         unsigned int hrate, drate, maxyres;
1253
1254         inSISIDXREG(SISSR, IND_SIS_COLOR_MODE, sr_data);
1255
1256         if(sr_data & SIS_INTERLACED_MODE)
1257            var->vmode = FB_VMODE_INTERLACED;
1258         else
1259            var->vmode = FB_VMODE_NONINTERLACED;
1260
1261         switch((sr_data & 0x1C) >> 2) {
1262         case SIS_8BPP_COLOR_MODE:
1263                 var->bits_per_pixel = 8;
1264                 break;
1265         case SIS_16BPP_COLOR_MODE:
1266                 var->bits_per_pixel = 16;
1267                 break;
1268         case SIS_32BPP_COLOR_MODE:
1269                 var->bits_per_pixel = 32;
1270                 break;
1271         }
1272
1273         sisfb_bpp_to_var(ivideo, var);
1274
1275         inSISIDXREG(SISSR, 0x0A, sr_data);
1276         inSISIDXREG(SISCR, 0x06, cr_data);
1277         inSISIDXREG(SISCR, 0x07, cr_data2);
1278
1279         VT = (cr_data & 0xFF) |
1280              ((u16) (cr_data2 & 0x01) << 8) |
1281              ((u16) (cr_data2 & 0x20) << 4) |
1282              ((u16) (sr_data  & 0x01) << 10);
1283         A = VT + 2;
1284
1285         inSISIDXREG(SISCR, 0x12, cr_data);
1286
1287         VDE = (cr_data & 0xff) |
1288               ((u16) (cr_data2 & 0x02) << 7) |
1289               ((u16) (cr_data2 & 0x40) << 3) |
1290               ((u16) (sr_data  & 0x02) << 9);
1291         E = VDE + 1;
1292
1293         inSISIDXREG(SISCR, 0x10, cr_data);
1294
1295         VRS = (cr_data & 0xff) |
1296               ((u16) (cr_data2 & 0x04) << 6) |
1297               ((u16) (cr_data2 & 0x80) << 2) |
1298               ((u16) (sr_data  & 0x08) << 7);
1299         F = VRS + 1 - E;
1300
1301         inSISIDXREG(SISCR, 0x15, cr_data);
1302         inSISIDXREG(SISCR, 0x09, cr_data3);
1303
1304         if(cr_data3 & 0x80) var->vmode = FB_VMODE_DOUBLE;
1305
1306         VBS = (cr_data & 0xff) |
1307               ((u16) (cr_data2 & 0x08) << 5) |
1308               ((u16) (cr_data3 & 0x20) << 4) |
1309               ((u16) (sr_data & 0x04) << 8);
1310
1311         inSISIDXREG(SISCR, 0x16, cr_data);
1312
1313         VBE = (cr_data & 0xff) | ((u16) (sr_data & 0x10) << 4);
1314         temp = VBE - ((E - 1) & 511);
1315         B = (temp > 0) ? temp : (temp + 512);
1316
1317         inSISIDXREG(SISCR, 0x11, cr_data);
1318
1319         VRE = (cr_data & 0x0f) | ((sr_data & 0x20) >> 1);
1320         temp = VRE - ((E + F - 1) & 31);
1321         C = (temp > 0) ? temp : (temp + 32);
1322
1323         D = B - F - C;
1324
1325         var->yres = E;
1326         var->upper_margin = D;
1327         var->lower_margin = F;
1328         var->vsync_len = C;
1329
1330         if((var->vmode & FB_VMODE_MASK) == FB_VMODE_INTERLACED) {
1331            var->yres <<= 1;
1332            var->upper_margin <<= 1;
1333            var->lower_margin <<= 1;
1334            var->vsync_len <<= 1;
1335         } else if((var->vmode & FB_VMODE_MASK) == FB_VMODE_DOUBLE) {
1336            var->yres >>= 1;
1337            var->upper_margin >>= 1;
1338            var->lower_margin >>= 1;
1339            var->vsync_len >>= 1;
1340         }
1341
1342         inSISIDXREG(SISSR, 0x0b, sr_data);
1343         inSISIDXREG(SISCR, 0x00, cr_data);
1344
1345         HT = (cr_data & 0xff) | ((u16) (sr_data & 0x03) << 8);
1346         A = HT + 5;
1347
1348         inSISIDXREG(SISCR, 0x01, cr_data);
1349
1350         HDE = (cr_data & 0xff) | ((u16) (sr_data & 0x0C) << 6);
1351         E = HDE + 1;
1352
1353         inSISIDXREG(SISCR, 0x04, cr_data);
1354
1355         HRS = (cr_data & 0xff) | ((u16) (sr_data & 0xC0) << 2);
1356         F = HRS - E - 3;
1357
1358         inSISIDXREG(SISCR, 0x02, cr_data);
1359
1360         HBS = (cr_data & 0xff) | ((u16) (sr_data & 0x30) << 4);
1361
1362         inSISIDXREG(SISSR, 0x0c, sr_data);
1363         inSISIDXREG(SISCR, 0x03, cr_data);
1364         inSISIDXREG(SISCR, 0x05, cr_data2);
1365
1366         HBE = (cr_data & 0x1f) |
1367               ((u16) (cr_data2 & 0x80) >> 2) |
1368               ((u16) (sr_data  & 0x03) << 6);
1369         HRE = (cr_data2 & 0x1f) | ((sr_data & 0x04) << 3);
1370
1371         temp = HBE - ((E - 1) & 255);
1372         B = (temp > 0) ? temp : (temp + 256);
1373
1374         temp = HRE - ((E + F + 3) & 63);
1375         C = (temp > 0) ? temp : (temp + 64);
1376
1377         D = B - F - C;
1378
1379         var->xres = E * 8;
1380         if(var->xres_virtual < var->xres) {
1381                 var->xres_virtual = var->xres;
1382         }
1383
1384         if((var->xres == 320) &&
1385            (var->yres == 200 || var->yres == 240)) {
1386                 /* Terrible hack, but the correct CRTC data for
1387                  * these modes only produces a black screen...
1388                  */
1389                 var->left_margin = (400 - 376);
1390                 var->right_margin = (328 - 320);
1391                 var->hsync_len = (376 - 328);
1392         } else {
1393                 var->left_margin = D * 8;
1394                 var->right_margin = F * 8;
1395                 var->hsync_len = C * 8;
1396         }
1397         var->activate = FB_ACTIVATE_NOW;
1398
1399         var->sync = 0;
1400
1401         mr_data = inSISREG(SISMISCR);
1402         if(mr_data & 0x80)
1403            var->sync &= ~FB_SYNC_VERT_HIGH_ACT;
1404         else
1405            var->sync |= FB_SYNC_VERT_HIGH_ACT;
1406
1407         if(mr_data & 0x40)
1408            var->sync &= ~FB_SYNC_HOR_HIGH_ACT;
1409         else
1410            var->sync |= FB_SYNC_HOR_HIGH_ACT;
1411
1412         VT += 2;
1413         VT <<= 1;
1414         HT = (HT + 5) * 8;
1415
1416         if((var->vmode & FB_VMODE_MASK) == FB_VMODE_INTERLACED) {
1417            VT <<= 1;
1418         }
1419         hrate = ivideo->refresh_rate * VT / 2;
1420         drate = (hrate * HT) / 1000;
1421         var->pixclock = (u32) (1000000000 / drate);
1422
1423         if(ivideo->sisfb_ypan) {
1424            maxyres = sisfb_calc_maxyres(ivideo, var);
1425            if(ivideo->sisfb_max) {
1426               var->yres_virtual = maxyres;
1427            } else {
1428               if(var->yres_virtual > maxyres) {
1429                  var->yres_virtual = maxyres;
1430               }
1431            }
1432            if(var->yres_virtual <= var->yres) {
1433               var->yres_virtual = var->yres;
1434            }
1435         } else {
1436            var->yres_virtual = var->yres;
1437         }
1438
1439 }
1440
1441 static int
1442 sis_getcolreg(unsigned regno, unsigned *red, unsigned *green, unsigned *blue,
1443                          unsigned *transp, struct fb_info *info)
1444 {
1445         struct sis_video_info *ivideo = (struct sis_video_info *)info->par;
1446
1447         if(regno >= ivideo->video_cmap_len) return 1;
1448
1449         *red   = ivideo->sis_palette[regno].red;
1450         *green = ivideo->sis_palette[regno].green;
1451         *blue  = ivideo->sis_palette[regno].blue;
1452         *transp = 0;
1453
1454         return 0;
1455 }
1456
1457 static int
1458 sisfb_setcolreg(unsigned regno, unsigned red, unsigned green, unsigned blue,
1459                            unsigned transp, struct fb_info *info)
1460 {
1461         struct sis_video_info *ivideo = (struct sis_video_info *)info->par;
1462
1463         if(regno >= ivideo->video_cmap_len) return 1;
1464
1465         ivideo->sis_palette[regno].red   = red;
1466         ivideo->sis_palette[regno].green = green;
1467         ivideo->sis_palette[regno].blue  = blue;
1468
1469         switch(ivideo->video_bpp) {
1470 #ifdef FBCON_HAS_CFB8
1471         case 8:
1472                 outSISREG(SISDACA, regno);
1473                 outSISREG(SISDACD, (red >> 10));
1474                 outSISREG(SISDACD, (green >> 10));
1475                 outSISREG(SISDACD, (blue >> 10));
1476                 if(ivideo->currentvbflags & VB_DISPTYPE_DISP2) {
1477                         outSISREG(SISDAC2A, regno);
1478                         outSISREG(SISDAC2D, (red >> 8));
1479                         outSISREG(SISDAC2D, (green >> 8));
1480                         outSISREG(SISDAC2D, (blue >> 8));
1481                 }
1482                 break;
1483 #endif
1484 #ifdef FBCON_HAS_CFB16
1485         case 16:
1486                 ivideo->sis_fbcon_cmap.cfb16[regno] =
1487                     ((red & 0xf800)) | ((green & 0xfc00) >> 5) | ((blue & 0xf800) >> 11);
1488                 break;
1489 #endif
1490 #ifdef FBCON_HAS_CFB32
1491         case 32:
1492                 red   >>= 8;
1493                 green >>= 8;
1494                 blue  >>= 8;
1495                 ivideo->sis_fbcon_cmap.cfb32[regno] = (red << 16) | (green << 8) | (blue);
1496                 break;
1497 #endif
1498         }
1499
1500         return 0;
1501 }
1502
1503 static void
1504 sisfb_set_disp(int con, struct fb_var_screeninfo *var, struct fb_info *info)
1505 {
1506         struct sis_video_info    *ivideo = (struct sis_video_info *)info->par;
1507         struct display           *display;
1508         struct display_switch    *sw;
1509         struct fb_fix_screeninfo fix;
1510         long   flags;
1511
1512         display = (con >= 0) ? &fb_display[con] : &ivideo->sis_disp;
1513
1514         sisfb_get_fix(&fix, con, info);
1515
1516         display->var = *var;
1517         display->screen_base = (char *)ivideo->video_vbase;
1518         display->visual = fix.visual;
1519         display->type = fix.type;
1520         display->type_aux = fix.type_aux;
1521         display->ypanstep = fix.ypanstep;
1522         display->ywrapstep = fix.ywrapstep;
1523         display->line_length = fix.line_length;
1524         display->can_soft_blank = 1;
1525         display->inverse = ivideo->sisfb_inverse;
1526         display->next_line = fix.line_length;
1527
1528         save_flags(flags);
1529
1530         switch(ivideo->video_bpp) {
1531 #ifdef FBCON_HAS_CFB8
1532         case 8: sw = ivideo->accel ? &fbcon_sis8 : &fbcon_cfb8;
1533                 break;
1534 #endif
1535 #ifdef FBCON_HAS_CFB16
1536         case 16:sw = ivideo->accel ? &fbcon_sis16 : &fbcon_cfb16;
1537                 display->dispsw_data = &ivideo->sis_fbcon_cmap.cfb16;
1538                 break;
1539 #endif
1540 #ifdef FBCON_HAS_CFB32
1541         case 32:sw = ivideo->accel ? &fbcon_sis32 : &fbcon_cfb32;
1542                 display->dispsw_data = &ivideo->sis_fbcon_cmap.cfb32;
1543                 break;
1544 #endif
1545         default:sw = &fbcon_dummy;
1546                 break;
1547         }
1548         memcpy(&ivideo->sisfb_sw, sw, sizeof(*sw));
1549         display->dispsw = &ivideo->sisfb_sw;
1550
1551         restore_flags(flags);
1552
1553         if(ivideo->sisfb_ypan) {
1554             /* display->scrollmode = 0;  */
1555         } else {
1556             display->scrollmode = SCROLL_YREDRAW;
1557             ivideo->sisfb_sw.bmove = fbcon_redraw_bmove;
1558         }
1559 }
1560
1561 static void
1562 sisfb_do_install_cmap(int con, struct fb_info *info)
1563 {
1564         struct sis_video_info *ivideo = (struct sis_video_info *)info->par;
1565
1566         if(con != ivideo->currcon) return;
1567
1568         if(fb_display[con].cmap.len) {
1569                 fb_set_cmap(&fb_display[con].cmap, sisfb_setcolreg, info);
1570         } else {
1571                 int size = sisfb_get_cmap_len(&fb_display[con].var);
1572                 fb_set_cmap(fb_default_cmap(size), sisfb_setcolreg, info);
1573         }
1574 }
1575
1576 static int
1577 sisfb_get_var(struct fb_var_screeninfo *var, int con, struct fb_info *info)
1578 {
1579         struct sis_video_info *ivideo = (struct sis_video_info *)info->par;
1580
1581         if(con == -1) {
1582                 memcpy(var, &ivideo->default_var, sizeof(struct fb_var_screeninfo));
1583         } else {
1584                 *var = fb_display[con].var;
1585         }
1586
1587         if(ivideo->sisfb_fstn) {
1588                 if(var->xres == 320 && var->yres == 480) var->yres = 240;
1589         }
1590
1591         return 0;
1592 }
1593
1594 static int
1595 sisfb_set_var(struct fb_var_screeninfo *var, int con, struct fb_info *info)
1596 {
1597         struct sis_video_info *ivideo = (struct sis_video_info *)info->par;
1598         int err;
1599
1600         fb_display[con].var.activate = FB_ACTIVATE_NOW;
1601
1602         if(sisfb_do_set_var(var, con == ivideo->currcon, info)) {
1603                 sisfb_crtc_to_var(ivideo, var);
1604                 return -EINVAL;
1605         }
1606
1607         sisfb_crtc_to_var(ivideo, var);
1608
1609         sisfb_set_disp(con, var, info);
1610
1611         if(info->changevar) {
1612                 (*info->changevar)(con);
1613         }
1614
1615         if((err = fb_alloc_cmap(&fb_display[con].cmap, 0, 0))) {
1616                 return err;
1617         }
1618
1619         sisfb_do_install_cmap(con, info);
1620
1621 #if 0   /* Why was this called here? */
1622         unsigned int cols, rows;
1623         cols = sisbios_mode[ivideo->sisfb_mode_idx].cols;
1624         rows = sisbios_mode[ivideo->sisfb_mode_idx].rows;
1625         vc_resize_con(rows, cols, fb_display[con].conp->vc_num);
1626 #endif
1627         return 0;
1628 }
1629
1630 static int
1631 sisfb_get_cmap(struct fb_cmap *cmap, int kspc, int con, struct fb_info *info)
1632 {
1633         struct sis_video_info *ivideo = (struct sis_video_info *)info->par;
1634         struct display *display;
1635
1636         display = (con >= 0) ? &fb_display[con] : &ivideo->sis_disp;
1637
1638         if(con == ivideo->currcon) {
1639
1640                 return fb_get_cmap(cmap, kspc, sis_getcolreg, info);
1641
1642         } else if(display->cmap.len) {
1643
1644                 fb_copy_cmap(&display->cmap, cmap, kspc ? 0 : 2);
1645
1646         } else {
1647
1648                 int size = sisfb_get_cmap_len(&display->var);
1649                 fb_copy_cmap(fb_default_cmap(size), cmap, kspc ? 0 : 2);
1650
1651         }
1652
1653         return 0;
1654 }
1655
1656 static int
1657 sisfb_set_cmap(struct fb_cmap *cmap, int kspc, int con, struct fb_info *info)
1658 {
1659         struct sis_video_info *ivideo = (struct sis_video_info *)info->par;
1660         struct display *display;
1661         int err, size;
1662
1663         display = (con >= 0) ? &fb_display[con] : &ivideo->sis_disp;
1664
1665         size = sisfb_get_cmap_len(&display->var);
1666         if(display->cmap.len != size) {
1667                 err = fb_alloc_cmap(&display->cmap, size, 0);
1668                 if(err) return err;
1669         }
1670
1671         if(con == ivideo->currcon) {
1672                 return fb_set_cmap(cmap, kspc, sisfb_setcolreg, info);
1673         } else {
1674                 fb_copy_cmap(cmap, &display->cmap, kspc ? 0 : 1);
1675         }
1676
1677         return 0;
1678 }
1679
1680 static int
1681 sisfb_pan_display(struct fb_var_screeninfo *var, int con, struct fb_info* info)
1682 {
1683         struct sis_video_info *ivideo = (struct sis_video_info *)info->par;
1684         int err;
1685
1686         if(var->vmode & FB_VMODE_YWRAP) return -EINVAL;
1687
1688         if((var->xoffset+fb_display[con].var.xres > fb_display[con].var.xres_virtual) ||
1689            (var->yoffset+fb_display[con].var.yres > fb_display[con].var.yres_virtual)) {
1690                 return -EINVAL;
1691         }
1692
1693         if(con == ivideo->currcon) {
1694                 if((err = sisfb_pan_var(ivideo, var)) < 0) return err;
1695         }
1696
1697         fb_display[con].var.xoffset = var->xoffset;
1698         fb_display[con].var.yoffset = var->yoffset;
1699
1700         return 0;
1701 }
1702
1703 static int
1704 sisfb_update_var(int con, struct fb_info *info)
1705 {
1706         struct sis_video_info *ivideo = (struct sis_video_info *)info->par;
1707
1708         return(sisfb_pan_var(ivideo, &fb_display[con].var));
1709 }
1710
1711 static int
1712 sisfb_switch(int con, struct fb_info *info)
1713 {
1714         struct sis_video_info *ivideo = (struct sis_video_info *)info->par;
1715         int cols, rows;
1716
1717         if(fb_display[ivideo->currcon].cmap.len) {
1718                 fb_get_cmap(&fb_display[ivideo->currcon].cmap, 1, sis_getcolreg, info);
1719         }
1720
1721         fb_display[con].var.activate = FB_ACTIVATE_NOW;
1722
1723         if(!memcmp(&fb_display[con].var, &fb_display[ivideo->currcon].var,
1724                                         sizeof(struct fb_var_screeninfo))) {
1725                 ivideo->currcon = con;
1726                 return 1;
1727         }
1728
1729         ivideo->currcon = con;
1730
1731         sisfb_do_set_var(&fb_display[con].var, 1, info);
1732
1733         sisfb_set_disp(con, &fb_display[con].var, info);
1734
1735         sisfb_do_install_cmap(con, info);
1736
1737         cols = sisbios_mode[ivideo->sisfb_mode_idx].cols;
1738         rows = sisbios_mode[ivideo->sisfb_mode_idx].rows;
1739         vc_resize_con(rows, cols, fb_display[con].conp->vc_num);
1740
1741         sisfb_update_var(con, info);
1742
1743         return 1;
1744 }
1745
1746 static void
1747 sisfb_blank(int blank, struct fb_info *info)
1748 {
1749         struct sis_video_info *ivideo = (struct sis_video_info *)info->par;
1750
1751         sisfb_myblank(ivideo, blank);
1752 }
1753 #endif
1754
1755 /* ------------ FBDev related routines for 2.6 series ----------- */
1756
1757 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)
1758
1759 static int
1760 sisfb_open(struct fb_info *info, int user)
1761 {
1762         return 0;
1763 }
1764
1765 static int
1766 sisfb_release(struct fb_info *info, int user)
1767 {
1768         return 0;
1769 }
1770
1771 static int
1772 sisfb_setcolreg(unsigned regno, unsigned red, unsigned green, unsigned blue,
1773                 unsigned transp, struct fb_info *info)
1774 {
1775         struct sis_video_info *ivideo = (struct sis_video_info *)info->par;
1776
1777         if(regno >= sisfb_get_cmap_len(&info->var)) return 1;
1778
1779         switch(info->var.bits_per_pixel) {
1780         case 8:
1781                 outSISREG(SISDACA, regno);
1782                 outSISREG(SISDACD, (red >> 10));
1783                 outSISREG(SISDACD, (green >> 10));
1784                 outSISREG(SISDACD, (blue >> 10));
1785                 if(ivideo->currentvbflags & VB_DISPTYPE_DISP2) {
1786                         outSISREG(SISDAC2A, regno);
1787                         outSISREG(SISDAC2D, (red >> 8));
1788                         outSISREG(SISDAC2D, (green >> 8));
1789                         outSISREG(SISDAC2D, (blue >> 8));
1790                 }
1791                 break;
1792         case 16:
1793                 ((u32 *)(info->pseudo_palette))[regno] =
1794                     ((red & 0xf800)) | ((green & 0xfc00) >> 5) | ((blue & 0xf800) >> 11);
1795                 break;
1796         case 32:
1797                 red >>= 8;
1798                 green >>= 8;
1799                 blue >>= 8;
1800                 ((u32 *)(info->pseudo_palette))[regno] =
1801                                 (red << 16) | (green << 8) | (blue);
1802                 break;
1803         }
1804         return 0;
1805 }
1806
1807 static int
1808 sisfb_set_par(struct fb_info *info)
1809 {
1810         int err;
1811
1812         if((err = sisfb_do_set_var(&info->var, 1, info))) {
1813                 return err;
1814         }
1815
1816         sisfb_get_fix(&info->fix, info->currcon, info);
1817
1818         return 0;
1819 }
1820
1821 static int
1822 sisfb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
1823 {
1824         struct sis_video_info *ivideo = (struct sis_video_info *)info->par;
1825         unsigned int htotal = 0, vtotal = 0, myrateindex = 0;
1826         unsigned int drate = 0, hrate = 0, maxyres;
1827         int found_mode = 0;
1828         int refresh_rate, search_idx;
1829         BOOLEAN recalc_clock = FALSE;
1830         u32 pixclock;
1831
1832         htotal = var->left_margin + var->xres + var->right_margin + var->hsync_len;
1833
1834         vtotal = var->upper_margin + var->lower_margin + var->vsync_len;
1835
1836         pixclock = var->pixclock;
1837
1838         if((var->vmode & FB_VMODE_MASK) == FB_VMODE_NONINTERLACED) {
1839                 vtotal += var->yres;
1840                 vtotal <<= 1;
1841         } else if((var->vmode & FB_VMODE_MASK) == FB_VMODE_DOUBLE) {
1842                 vtotal += var->yres;
1843                 vtotal <<= 2;
1844         } else if((var->vmode & FB_VMODE_MASK) == FB_VMODE_INTERLACED) {
1845                 vtotal += var->yres;
1846                 vtotal <<= 1;
1847         } else  vtotal += var->yres;
1848
1849         if(!(htotal) || !(vtotal)) {
1850                 SISFAIL("sisfb: no valid timing data");
1851         }
1852
1853         search_idx = 0;
1854         while( (sisbios_mode[search_idx].mode_no[0] != 0) &&
1855                (sisbios_mode[search_idx].xres <= var->xres) ) {
1856                 if( (sisbios_mode[search_idx].xres == var->xres) &&
1857                     (sisbios_mode[search_idx].yres == var->yres) &&
1858                     (sisbios_mode[search_idx].bpp == var->bits_per_pixel)) {
1859                         if(sisfb_validate_mode(ivideo, search_idx, ivideo->currentvbflags) > 0) {
1860                            found_mode = 1;
1861                            break;
1862                         }
1863                 }
1864                 search_idx++;
1865         }
1866
1867         if(!found_mode) {
1868                 search_idx = 0;
1869                 while(sisbios_mode[search_idx].mode_no[0] != 0) {
1870                    if( (var->xres <= sisbios_mode[search_idx].xres) &&
1871                        (var->yres <= sisbios_mode[search_idx].yres) &&
1872                        (var->bits_per_pixel == sisbios_mode[search_idx].bpp) ) {
1873                           if(sisfb_validate_mode(ivideo,search_idx, ivideo->currentvbflags) > 0) {
1874                              found_mode = 1;
1875                              break;
1876                           }
1877                    }
1878                    search_idx++;
1879                 }
1880                 if(found_mode) {
1881                         printk(KERN_DEBUG "sisfb: Adapted from %dx%dx%d to %dx%dx%d\n",
1882                                 var->xres, var->yres, var->bits_per_pixel,
1883                                 sisbios_mode[search_idx].xres,
1884                                 sisbios_mode[search_idx].yres,
1885                                 var->bits_per_pixel);
1886                         var->xres = sisbios_mode[search_idx].xres;
1887                         var->yres = sisbios_mode[search_idx].yres;
1888
1889
1890                 } else {
1891                         printk(KERN_ERR "sisfb: Failed to find supported mode near %dx%dx%d\n",
1892                                 var->xres, var->yres, var->bits_per_pixel);
1893                         return -EINVAL;
1894                 }
1895         }
1896
1897         if( ((ivideo->vbflags & VB_LVDS) ||                     /* Slave modes on LVDS and 301B-DH */
1898              ((ivideo->vbflags & VB_30xBDH) && (ivideo->currentvbflags & CRT2_LCD))) &&
1899             (var->bits_per_pixel == 8) ) {
1900                 refresh_rate = 60;
1901                 recalc_clock = TRUE;
1902         } else if( (ivideo->current_htotal == htotal) &&        /* x=x & y=y & c=c -> assume depth change */
1903                    (ivideo->current_vtotal == vtotal) &&
1904                    (ivideo->current_pixclock == pixclock) ) {
1905                 drate = 1000000000 / pixclock;
1906                 hrate = (drate * 1000) / htotal;
1907                 refresh_rate = (unsigned int) (hrate * 2 / vtotal);
1908         } else if( ( (ivideo->current_htotal != htotal) ||      /* x!=x | y!=y & c=c -> invalid pixclock */
1909                      (ivideo->current_vtotal != vtotal) ) &&
1910                    (ivideo->current_pixclock == var->pixclock) ) {
1911                 if(ivideo->sisfb_lastrates[sisbios_mode[search_idx].mode_no[ivideo->mni]]) {
1912                         refresh_rate = ivideo->sisfb_lastrates[sisbios_mode[search_idx].mode_no[ivideo->mni]];
1913                 } else if(ivideo->sisfb_parm_rate != -1) {
1914                         /* Sic, sisfb_parm_rate - want to know originally desired rate here */
1915                         refresh_rate = ivideo->sisfb_parm_rate;
1916                 } else {
1917                         refresh_rate = 60;
1918                 }
1919                 recalc_clock = TRUE;
1920         } else if((pixclock) && (htotal) && (vtotal)) {
1921                 drate = 1000000000 / pixclock;
1922                 hrate = (drate * 1000) / htotal;
1923                 refresh_rate = (unsigned int) (hrate * 2 / vtotal);
1924         } else if(ivideo->current_refresh_rate) {
1925                 refresh_rate = ivideo->current_refresh_rate;
1926                 recalc_clock = TRUE;
1927         } else {
1928                 refresh_rate = 60;
1929                 recalc_clock = TRUE;
1930         }
1931
1932         myrateindex = sisfb_search_refresh_rate(ivideo, refresh_rate, search_idx);
1933
1934         /* Eventually recalculate timing and clock */
1935         if(recalc_clock) {
1936            if(!myrateindex) myrateindex = sisbios_mode[search_idx].rate_idx;
1937            var->pixclock = (u32) (1000000000 / sisfb_mode_rate_to_dclock(&ivideo->SiS_Pr,
1938                                                 &ivideo->sishw_ext,
1939                                                 sisbios_mode[search_idx].mode_no[ivideo->mni],
1940                                                 myrateindex));
1941            sisfb_mode_rate_to_ddata(&ivideo->SiS_Pr, &ivideo->sishw_ext,
1942                                     sisbios_mode[search_idx].mode_no[ivideo->mni], myrateindex, var);
1943            if((var->vmode & FB_VMODE_MASK) == FB_VMODE_DOUBLE) {
1944               var->pixclock <<= 1;
1945            }
1946         }
1947
1948         if(ivideo->sisfb_thismonitor.datavalid) {
1949            if(!sisfb_verify_rate(ivideo, &ivideo->sisfb_thismonitor, search_idx,
1950                                  myrateindex, refresh_rate)) {
1951               printk(KERN_INFO "sisfb: WARNING: Refresh rate exceeds monitor specs!\n");
1952            }
1953         }
1954
1955         /* Adapt RGB settings */
1956         sisfb_bpp_to_var(ivideo, var);
1957
1958         /* Sanity check for offsets */
1959         if(var->xoffset < 0) var->xoffset = 0;
1960         if(var->yoffset < 0) var->yoffset = 0;
1961
1962         if(var->xres > var->xres_virtual) {
1963            var->xres_virtual = var->xres;
1964         }
1965
1966         if(ivideo->sisfb_ypan) {
1967            maxyres = sisfb_calc_maxyres(ivideo, var);
1968            if(ivideo->sisfb_max) {
1969               var->yres_virtual = maxyres;
1970            } else {
1971               if(var->yres_virtual > maxyres) {
1972                  var->yres_virtual = maxyres;
1973               }
1974            }
1975            if(var->yres_virtual <= var->yres) {
1976               var->yres_virtual = var->yres;
1977            }
1978         } else {
1979            if(var->yres != var->yres_virtual) {
1980               var->yres_virtual = var->yres;
1981            }
1982            var->xoffset = 0;
1983            var->yoffset = 0;
1984         }
1985
1986         /* Truncate offsets to maximum if too high */
1987         if(var->xoffset > var->xres_virtual - var->xres) {
1988            var->xoffset = var->xres_virtual - var->xres - 1;
1989         }
1990
1991         if(var->yoffset > var->yres_virtual - var->yres) {
1992            var->yoffset = var->yres_virtual - var->yres - 1;
1993         }
1994
1995         /* Set everything else to 0 */
1996         var->red.msb_right =
1997         var->green.msb_right =
1998         var->blue.msb_right =
1999         var->transp.offset =
2000         var->transp.length =
2001         var->transp.msb_right = 0;
2002
2003         return 0;
2004 }
2005
2006 static int
2007 sisfb_pan_display(struct fb_var_screeninfo *var, struct fb_info* info)
2008 {
2009         struct sis_video_info *ivideo = (struct sis_video_info *)info->par;
2010         int err;
2011
2012         if(var->xoffset > (var->xres_virtual - var->xres)) {
2013                 return -EINVAL;
2014         }
2015         if(var->yoffset > (var->yres_virtual - var->yres)) {
2016                 return -EINVAL;
2017         }
2018
2019         if(var->vmode & FB_VMODE_YWRAP) return -EINVAL;
2020
2021         if(var->xoffset + info->var.xres > info->var.xres_virtual ||
2022            var->yoffset + info->var.yres > info->var.yres_virtual) {
2023                 return -EINVAL;
2024         }
2025
2026         if((err = sisfb_pan_var(ivideo, var)) < 0) return err;
2027
2028         info->var.xoffset = var->xoffset;
2029         info->var.yoffset = var->yoffset;
2030
2031         return 0;
2032 }
2033
2034 static int
2035 sisfb_blank(int blank, struct fb_info *info)
2036 {
2037         struct sis_video_info *ivideo = (struct sis_video_info *)info->par;
2038
2039         return(sisfb_myblank(ivideo, blank));
2040 }
2041
2042 #endif
2043
2044 /* ----------- FBDev related routines for all series ---------- */
2045
2046 static int
2047 sisfb_ioctl(struct inode *inode, struct file *file,
2048             unsigned int cmd, unsigned long arg,
2049 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
2050             int con,
2051 #endif
2052             struct fb_info *info)
2053 {
2054         struct sis_video_info   *ivideo = (struct sis_video_info *)info->par;
2055         struct sis_memreq       sismemreq;
2056         struct fb_vblank        sisvbblank;
2057         sisfb_info              x;
2058         u32                     gpu32 = 0;
2059         static int              count = 0;
2060         u32 __user              *argp = (u32 __user *) arg;
2061
2062         switch (cmd) {
2063            case FBIO_ALLOC:
2064                 if(!capable(CAP_SYS_RAWIO)) {
2065                         return -EPERM;
2066                 }
2067                 if(copy_from_user(&sismemreq, argp, sizeof(sismemreq))) {
2068                         return -EFAULT;
2069                 }
2070                 sis_malloc(&sismemreq);
2071                 if(copy_to_user(argp, &sismemreq, sizeof(sismemreq))) {
2072                         sis_free((u32)sismemreq.offset);
2073                         return -EFAULT;
2074                 }
2075                 break;
2076
2077            case FBIO_FREE:
2078                 if(!capable(CAP_SYS_RAWIO)) {
2079                         return -EPERM;
2080                 }
2081                 if(get_user(gpu32, argp)) {
2082                         return -EFAULT;
2083                 }
2084                 sis_free(gpu32);
2085                 break;
2086
2087            case FBIOGET_VBLANK:
2088                 sisvbblank.count = 0;
2089                 sisvbblank.flags = sisfb_setupvbblankflags(ivideo, &sisvbblank.vcount, &sisvbblank.hcount);
2090                 if(copy_to_user(argp, &sisvbblank, sizeof(sisvbblank))) {
2091                         return -EFAULT;
2092                 }
2093                 break;
2094
2095            case SISFB_GET_INFO_SIZE:
2096                 return put_user(sizeof(sisfb_info), argp);
2097
2098            case SISFB_GET_INFO_OLD:
2099                 if(++count < 50) {
2100                    printk(KERN_INFO "sisfb: Deprecated ioctl call received - update your application!\n");
2101                 }
2102            case SISFB_GET_INFO:  /* For communication with X driver */
2103                 x.sisfb_id         = SISFB_ID;
2104                 x.sisfb_version    = VER_MAJOR;
2105                 x.sisfb_revision   = VER_MINOR;
2106                 x.sisfb_patchlevel = VER_LEVEL;
2107                 x.chip_id = ivideo->chip_id;
2108                 x.memory = ivideo->video_size / 1024;
2109                 x.heapstart = ivideo->heapstart / 1024;
2110                 if(ivideo->modechanged) {
2111                    x.fbvidmode = ivideo->mode_no;
2112                 } else {
2113                    x.fbvidmode = ivideo->modeprechange;
2114                 }
2115                 x.sisfb_caps = ivideo->caps;
2116                 x.sisfb_tqlen = 512; /* yet fixed */
2117                 x.sisfb_pcibus = ivideo->pcibus;
2118                 x.sisfb_pcislot = ivideo->pcislot;
2119                 x.sisfb_pcifunc = ivideo->pcifunc;
2120                 x.sisfb_lcdpdc = ivideo->detectedpdc;
2121                 x.sisfb_lcdpdca = ivideo->detectedpdca;
2122                 x.sisfb_lcda = ivideo->detectedlcda;
2123                 x.sisfb_vbflags = ivideo->vbflags;
2124                 x.sisfb_currentvbflags = ivideo->currentvbflags;
2125                 x.sisfb_scalelcd = ivideo->SiS_Pr.UsePanelScaler;
2126                 x.sisfb_specialtiming = ivideo->SiS_Pr.SiS_CustomT;
2127                 x.sisfb_haveemi = ivideo->SiS_Pr.HaveEMI ? 1 : 0;
2128                 x.sisfb_haveemilcd = ivideo->SiS_Pr.HaveEMILCD ? 1 : 0;
2129                 x.sisfb_emi30 = ivideo->SiS_Pr.EMI_30;
2130                 x.sisfb_emi31 = ivideo->SiS_Pr.EMI_31;
2131                 x.sisfb_emi32 = ivideo->SiS_Pr.EMI_32;
2132                 x.sisfb_emi33 = ivideo->SiS_Pr.EMI_33;
2133                 x.sisfb_tvxpos = (u16)(ivideo->tvxpos + 32);
2134                 x.sisfb_tvypos = (u16)(ivideo->tvypos + 32);
2135
2136                 if(copy_to_user(argp, &x, sizeof(x))) {
2137                         return -EFAULT;
2138                 }
2139                 break;
2140
2141            case SISFB_GET_VBRSTATUS_OLD:
2142                 if(++count < 50) {
2143                    printk(KERN_INFO "sisfb: Deprecated ioctl call received - update your application!\n");
2144                 }
2145            case SISFB_GET_VBRSTATUS:
2146                 if(sisfb_CheckVBRetrace(ivideo)) {
2147                         return put_user((u32)1, argp);
2148                 } else {
2149                         return put_user((u32)0, argp);
2150                 }
2151
2152            case SISFB_GET_AUTOMAXIMIZE_OLD:
2153                 if(++count < 50) {
2154                    printk(KERN_INFO "sisfb: Deprecated ioctl call received - update your application!\n");
2155                 }
2156            case SISFB_GET_AUTOMAXIMIZE:
2157                 if(ivideo->sisfb_max) return put_user((u32)1, argp);
2158                 else                  return put_user((u32)0, argp);
2159
2160            case SISFB_SET_AUTOMAXIMIZE_OLD:
2161                 if(++count < 50) {
2162                    printk(KERN_INFO "sisfb: Deprecated ioctl call received - update your application!\n");
2163                 }
2164            case SISFB_SET_AUTOMAXIMIZE:
2165                 if(copy_from_user(&gpu32, argp, sizeof(gpu32))) {
2166                         return -EFAULT;
2167                 }
2168                 ivideo->sisfb_max = (gpu32) ? 1 : 0;
2169                 break;
2170
2171            case SISFB_SET_TVPOSOFFSET:
2172                 if(copy_from_user(&gpu32, argp, sizeof(gpu32))) {
2173                         return -EFAULT;
2174                 }
2175                 sisfb_set_TVxposoffset(ivideo, ((int)(gpu32 >> 16)) - 32);
2176                 sisfb_set_TVyposoffset(ivideo, ((int)(gpu32 & 0xffff)) - 32);
2177                 break;
2178
2179            case SISFB_GET_TVPOSOFFSET:
2180                 return put_user((u32)(((ivideo->tvxpos+32)<<16)|((ivideo->tvypos+32)&0xffff)), argp);
2181
2182            case SISFB_SET_LOCK:
2183                 if(copy_from_user(&gpu32, argp, sizeof(gpu32))) {
2184                         return -EFAULT;
2185                 }
2186                 ivideo->sisfblocked = (gpu32) ? 1 : 0;
2187                 break;
2188
2189            default:
2190                 return -EINVAL;
2191         }
2192         return 0;
2193 }
2194
2195 static int
2196 sisfb_get_fix(struct fb_fix_screeninfo *fix, int con, struct fb_info *info)
2197 {
2198         struct sis_video_info *ivideo = (struct sis_video_info *)info->par;
2199
2200         memset(fix, 0, sizeof(struct fb_fix_screeninfo));
2201
2202         strcpy(fix->id, ivideo->myid);
2203
2204         fix->smem_start  = ivideo->video_base;
2205         fix->smem_len    = ivideo->sisfb_mem;
2206         fix->type        = FB_TYPE_PACKED_PIXELS;
2207         fix->type_aux    = 0;
2208         fix->visual      = (ivideo->video_bpp == 8) ? FB_VISUAL_PSEUDOCOLOR : FB_VISUAL_TRUECOLOR;
2209         fix->xpanstep    = 1;
2210         fix->ypanstep    = (ivideo->sisfb_ypan) ? 1 : 0;
2211         fix->ywrapstep   = 0;
2212         fix->line_length = ivideo->video_linelength;
2213         fix->mmio_start  = ivideo->mmio_base;
2214         fix->mmio_len    = ivideo->mmio_size;
2215         if(ivideo->sisvga_engine == SIS_300_VGA) {
2216            fix->accel    = FB_ACCEL_SIS_GLAMOUR;
2217         } else if((ivideo->chip == SIS_330) || (ivideo->chip == SIS_760)) {
2218            fix->accel    = FB_ACCEL_SIS_XABRE;
2219         } else {
2220            fix->accel    = FB_ACCEL_SIS_GLAMOUR_2;
2221         }
2222
2223         return 0;
2224 }
2225
2226 /* ----------------  fb_ops structures ----------------- */
2227
2228 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
2229 static struct fb_ops sisfb_ops = {
2230         .owner          = THIS_MODULE,
2231         .fb_get_fix     = sisfb_get_fix,
2232         .fb_get_var     = sisfb_get_var,
2233         .fb_set_var     = sisfb_set_var,
2234         .fb_get_cmap    = sisfb_get_cmap,
2235         .fb_set_cmap    = sisfb_set_cmap,
2236         .fb_pan_display = sisfb_pan_display,
2237         .fb_ioctl       = sisfb_ioctl
2238 };
2239 #endif
2240
2241 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)
2242 static struct fb_ops sisfb_ops = {
2243         .owner          = THIS_MODULE,
2244         .fb_open        = sisfb_open,
2245         .fb_release     = sisfb_release,
2246         .fb_check_var   = sisfb_check_var,
2247         .fb_set_par     = sisfb_set_par,
2248         .fb_setcolreg   = sisfb_setcolreg,
2249         .fb_pan_display = sisfb_pan_display,
2250         .fb_blank       = sisfb_blank,
2251         .fb_fillrect    = fbcon_sis_fillrect,
2252         .fb_copyarea    = fbcon_sis_copyarea,
2253         .fb_imageblit   = cfb_imageblit,
2254         .fb_cursor      = soft_cursor,
2255         .fb_sync        = fbcon_sis_sync,
2256         .fb_ioctl       = sisfb_ioctl
2257 };
2258 #endif
2259
2260 /* ---------------- Chip generation dependent routines ---------------- */
2261
2262 static struct pci_dev * sisfb_get_northbridge(int basechipid)
2263 {
2264         struct pci_dev *pdev = NULL;
2265         int nbridgenum, nbridgeidx, i;
2266         const unsigned short nbridgeids[] = {
2267                 PCI_DEVICE_ID_SI_540,   /* for SiS 540 VGA */
2268                 PCI_DEVICE_ID_SI_630,   /* for SiS 630/730 VGA */
2269                 PCI_DEVICE_ID_SI_730,
2270                 PCI_DEVICE_ID_SI_550,   /* for SiS 550 VGA */
2271                 PCI_DEVICE_ID_SI_650,   /* for SiS 650/651/740 VGA */
2272                 PCI_DEVICE_ID_SI_651,
2273                 PCI_DEVICE_ID_SI_740,
2274                 PCI_DEVICE_ID_SI_661,   /* for SiS 661/741/660/760 VGA */
2275                 PCI_DEVICE_ID_SI_741,
2276                 PCI_DEVICE_ID_SI_660,
2277                 PCI_DEVICE_ID_SI_760
2278         };
2279
2280         switch(basechipid) {
2281 #ifdef CONFIG_FB_SIS_300
2282         case SIS_540:   nbridgeidx = 0; nbridgenum = 1; break;
2283         case SIS_630:   nbridgeidx = 1; nbridgenum = 2; break;
2284 #endif
2285 #ifdef CONFIG_FB_SIS_315
2286         case SIS_550:   nbridgeidx = 3; nbridgenum = 1; break;
2287         case SIS_650:   nbridgeidx = 4; nbridgenum = 3; break;
2288         case SIS_660:   nbridgeidx = 7; nbridgenum = 4; break;
2289 #endif
2290         default:        return NULL;
2291         }
2292         for(i = 0; i < nbridgenum; i++) {
2293                 if((pdev = pci_find_device(PCI_VENDOR_ID_SI, nbridgeids[nbridgeidx+i], NULL))) break;
2294         }
2295         return pdev;
2296 }
2297
2298 static int __devinit sisfb_get_dram_size(struct sis_video_info *ivideo)
2299 {
2300 #if defined(CONFIG_FB_SIS_300) || defined(CONFIG_FB_SIS_315)
2301         u8 reg;
2302 #endif
2303
2304         ivideo->video_size = 0;
2305
2306         switch(ivideo->chip) {
2307 #ifdef CONFIG_FB_SIS_300
2308         case SIS_300:
2309                 inSISIDXREG(SISSR, 0x14, reg);
2310                 ivideo->video_size = ((reg & 0x3F) + 1) << 20;
2311                 break;
2312         case SIS_540:
2313         case SIS_630:
2314         case SIS_730:
2315                 if(!ivideo->nbridge) return -1;
2316                 pci_read_config_byte(ivideo->nbridge, 0x63, &reg);
2317                 ivideo->video_size = 1 << (((reg & 0x70) >> 4) + 21);
2318                 break;
2319 #endif
2320 #ifdef CONFIG_FB_SIS_315
2321         case SIS_315H:
2322         case SIS_315PRO:
2323         case SIS_315:
2324                 inSISIDXREG(SISSR, 0x14, reg);
2325                 ivideo->video_size = (1 << ((reg & 0xf0) >> 4)) << 20;
2326                 switch((reg >> 2) & 0x03) {
2327                 case 0x01:
2328                 case 0x03:
2329                    ivideo->video_size <<= 1;
2330                    break;
2331                 case 0x02:
2332                    ivideo->video_size += (ivideo->video_size/2);
2333                 }
2334                 break;
2335         case SIS_330:
2336                 inSISIDXREG(SISSR, 0x14, reg);
2337                 ivideo->video_size = (1 << ((reg & 0xf0) >> 4)) << 20;
2338                 if(reg & 0x0c) ivideo->video_size <<= 1;
2339                 break;
2340         case SIS_550:
2341         case SIS_650:
2342         case SIS_740:
2343                 inSISIDXREG(SISSR, 0x14, reg);
2344                 ivideo->video_size = (((reg & 0x3f) + 1) << 2) << 20;
2345                 break;
2346         case SIS_661:
2347         case SIS_741:
2348                 inSISIDXREG(SISCR, 0x79, reg);
2349                 ivideo->video_size = (1 << ((reg & 0xf0) >> 4)) << 20;
2350                 break;
2351         case SIS_660:
2352         case SIS_760:
2353                 inSISIDXREG(SISCR, 0x79, reg);
2354                 reg = (reg & 0xf0) >> 4;
2355                 if(reg) ivideo->video_size = (1 << reg) << 20;
2356                 inSISIDXREG(SISCR, 0x78, reg);
2357                 reg &= 0x30;
2358                 if(reg) {
2359                    if(reg == 0x10) ivideo->video_size += (32 << 20);
2360                    else            ivideo->video_size += (64 << 20);
2361                 }
2362                 break;
2363 #endif
2364         default:
2365                 return -1;
2366         }
2367         return 0;
2368 }
2369
2370 /* -------------- video bridge device detection --------------- */
2371
2372 static void __devinit sisfb_detect_VB_connect(struct sis_video_info *ivideo)
2373 {
2374         u8 cr32, temp;
2375
2376 #ifdef CONFIG_FB_SIS_300
2377         if(ivideo->sisvga_engine == SIS_300_VGA) {
2378                 inSISIDXREG(SISSR, 0x17, temp);
2379                 if((temp & 0x0F) && (ivideo->chip != SIS_300)) {
2380                         /* PAL/NTSC is stored on SR16 on such machines */
2381                         if(!(ivideo->vbflags & (TV_PAL | TV_NTSC | TV_PALM | TV_PALN))) {
2382                                 inSISIDXREG(SISSR, 0x16, temp);
2383                                 if(temp & 0x20)
2384                                         ivideo->vbflags |= TV_PAL;
2385                                 else
2386                                         ivideo->vbflags |= TV_NTSC;
2387                         }
2388                 }
2389         }
2390 #endif
2391
2392         inSISIDXREG(SISCR, 0x32, cr32);
2393
2394         if(cr32 & SIS_CRT1) {
2395                 ivideo->sisfb_crt1off = 0;
2396         } else {
2397                 ivideo->sisfb_crt1off = (cr32 & 0xDF) ? 1 : 0;
2398         }
2399
2400         ivideo->vbflags &= ~(CRT2_TV | CRT2_LCD | CRT2_VGA);
2401
2402         if(cr32 & SIS_VB_TV)   ivideo->vbflags |= CRT2_TV;
2403         if(cr32 & SIS_VB_LCD)  ivideo->vbflags |= CRT2_LCD;
2404         if(cr32 & SIS_VB_CRT2) ivideo->vbflags |= CRT2_VGA;
2405
2406         /* Check given parms for hardware compatibility.
2407          * (Cannot do this in the search_xx routines since we don't
2408          * know what hardware we are running on then)
2409          */
2410
2411         if(ivideo->chip != SIS_550) {
2412            ivideo->sisfb_dstn = ivideo->sisfb_fstn = 0;
2413         }
2414
2415         if(ivideo->sisfb_tvplug != -1) {
2416            if( (ivideo->sisvga_engine != SIS_315_VGA) ||
2417                (!(ivideo->vbflags & (VB_301C|VB_301LV|VB_302LV))) ) {
2418               if(ivideo->sisfb_tvplug & TV_YPBPR) {
2419                  ivideo->sisfb_tvplug = -1;
2420                  printk(KERN_ERR "sisfb: YPbPr not supported\n");
2421               }
2422            }
2423         }
2424         if(ivideo->sisfb_tvplug != -1) {
2425            if( (ivideo->sisvga_engine != SIS_315_VGA) ||
2426                (!(ivideo->vbflags & (VB_301|VB_301B|VB_302B))) ) {
2427               if(ivideo->sisfb_tvplug & TV_HIVISION) {
2428                  ivideo->sisfb_tvplug = -1;
2429                  printk(KERN_ERR "sisfb: HiVision not supported\n");
2430               }
2431            }
2432         }
2433         if(ivideo->sisfb_tvstd != -1) {
2434            if( (!(ivideo->vbflags & VB_SISBRIDGE)) &&
2435                (!((ivideo->sisvga_engine == SIS_315_VGA) && (ivideo->vbflags & VB_CHRONTEL))) ) {
2436               if(ivideo->sisfb_tvstd & (TV_PALN | TV_PALN | TV_NTSCJ)) {
2437                  ivideo->sisfb_tvstd = -1;
2438                  printk(KERN_ERR "sisfb: PALM/PALN/NTSCJ not supported\n");
2439               }
2440            }
2441         }
2442
2443         /* Detect/set TV plug & type */
2444         if(ivideo->sisfb_tvplug != -1) {
2445                 ivideo->vbflags |= ivideo->sisfb_tvplug;
2446         } else {
2447                 if(cr32 & SIS_VB_YPBPR)          ivideo->vbflags |= (TV_YPBPR|TV_YPBPR525I); /* default: 480i */
2448                 else if(cr32 & SIS_VB_HIVISION)  ivideo->vbflags |= TV_HIVISION;
2449                 else if(cr32 & SIS_VB_SCART)     ivideo->vbflags |= TV_SCART;
2450                 else {
2451                         if(cr32 & SIS_VB_SVIDEO)    ivideo->vbflags |= TV_SVIDEO;
2452                         if(cr32 & SIS_VB_COMPOSITE) ivideo->vbflags |= TV_AVIDEO;
2453                 }
2454         }
2455
2456         if(!(ivideo->vbflags & (TV_YPBPR | TV_HIVISION))) {
2457             if(ivideo->sisfb_tvstd != -1) {
2458                ivideo->vbflags &= ~(TV_NTSC | TV_PAL | TV_PALM | TV_PALN | TV_NTSCJ);
2459                ivideo->vbflags |= ivideo->sisfb_tvstd;
2460             }
2461             if(ivideo->vbflags & TV_SCART) {
2462                ivideo->vbflags &= ~(TV_NTSC | TV_PALM | TV_PALN | TV_NTSCJ);
2463                ivideo->vbflags |= TV_PAL;
2464             }
2465             if(!(ivideo->vbflags & (TV_PAL | TV_NTSC | TV_PALM | TV_PALN | TV_NTSCJ))) {
2466                 if(ivideo->sisvga_engine == SIS_300_VGA) {
2467                         inSISIDXREG(SISSR, 0x38, temp);
2468                         if(temp & 0x01) ivideo->vbflags |= TV_PAL;
2469                         else            ivideo->vbflags |= TV_NTSC;
2470                 } else if((ivideo->chip <= SIS_315PRO) || (ivideo->chip >= SIS_330)) {
2471                         inSISIDXREG(SISSR, 0x38, temp);
2472                         if(temp & 0x01) ivideo->vbflags |= TV_PAL;
2473                         else            ivideo->vbflags |= TV_NTSC;
2474                 } else {
2475                         inSISIDXREG(SISCR, 0x79, temp);
2476                         if(temp & 0x20) ivideo->vbflags |= TV_PAL;
2477                         else            ivideo->vbflags |= TV_NTSC;
2478                 }
2479             }
2480         }
2481
2482         /* Copy forceCRT1 option to CRT1off if option is given */
2483         if(ivideo->sisfb_forcecrt1 != -1) {
2484            ivideo->sisfb_crt1off = (ivideo->sisfb_forcecrt1) ? 0 : 1;
2485         }
2486 }
2487
2488 static void __devinit sisfb_get_VB_type(struct sis_video_info *ivideo)
2489 {
2490         char stdstr[]    = "sisfb: Detected";
2491         char bridgestr[] = "video bridge";
2492         u8 vb_chipid;
2493         u8 reg;
2494
2495         inSISIDXREG(SISPART4, 0x00, vb_chipid);
2496         switch(vb_chipid) {
2497         case 0x01:
2498                 inSISIDXREG(SISPART4, 0x01, reg);
2499                 if(reg < 0xb0) {
2500                         ivideo->vbflags |= VB_301;
2501                         printk(KERN_INFO "%s SiS301 %s\n", stdstr, bridgestr);
2502                 } else if(reg < 0xc0) {
2503                         ivideo->vbflags |= VB_301B;
2504                         inSISIDXREG(SISPART4,0x23,reg);
2505                         if(!(reg & 0x02)) {
2506                            ivideo->vbflags |= VB_30xBDH;
2507                            printk(KERN_INFO "%s SiS301B-DH %s\n", stdstr, bridgestr);
2508                         } else {
2509                            printk(KERN_INFO "%s SiS301B %s\n", stdstr, bridgestr);
2510                         }
2511                 } else if(reg < 0xd0) {
2512                         ivideo->vbflags |= VB_301C;
2513                         printk(KERN_INFO "%s SiS301C %s\n", stdstr, bridgestr);
2514                 } else if(reg < 0xe0) {
2515                         ivideo->vbflags |= VB_301LV;
2516                         printk(KERN_INFO "%s SiS301LV %s\n", stdstr, bridgestr);
2517                 } else if(reg <= 0xe1) {
2518                         inSISIDXREG(SISPART4,0x39,reg);
2519                         if(reg == 0xff) {
2520                            ivideo->vbflags |= VB_302LV;
2521                            printk(KERN_INFO "%s SiS302LV %s\n", stdstr, bridgestr);
2522                         } else {
2523                            ivideo->vbflags |= VB_301C;
2524                            printk(KERN_INFO "%s SiS301C(P4) %s\n", stdstr, bridgestr);
2525 #if 0
2526                            ivideo->vbflags |= VB_302ELV;
2527                            printk(KERN_INFO "%s SiS302ELV %s\n", stdstr, bridgestr);
2528 #endif
2529                         }
2530                 }
2531                 break;
2532         case 0x02:
2533                 ivideo->vbflags |= VB_302B;
2534                 printk(KERN_INFO "%s SiS302B %s\n", stdstr, bridgestr);
2535                 break;
2536         }
2537
2538         if((!(ivideo->vbflags & VB_VIDEOBRIDGE)) && (ivideo->chip != SIS_300)) {
2539                 inSISIDXREG(SISCR, 0x37, reg);
2540                 reg &= SIS_EXTERNAL_CHIP_MASK;
2541                 reg >>= 1;
2542                 if(ivideo->sisvga_engine == SIS_300_VGA) {
2543 #ifdef CONFIG_FB_SIS_300
2544                         switch(reg) {
2545                            case SIS_EXTERNAL_CHIP_LVDS:
2546                                 ivideo->vbflags |= VB_LVDS;
2547                                 break;
2548                            case SIS_EXTERNAL_CHIP_TRUMPION:
2549                                 ivideo->vbflags |= VB_TRUMPION;
2550                                 break;
2551                            case SIS_EXTERNAL_CHIP_CHRONTEL:
2552                                 ivideo->vbflags |= VB_CHRONTEL;
2553                                 break;
2554                            case SIS_EXTERNAL_CHIP_LVDS_CHRONTEL:
2555                                 ivideo->vbflags |= (VB_LVDS | VB_CHRONTEL);
2556                                 break;
2557                         }
2558                         if(ivideo->vbflags & VB_CHRONTEL) ivideo->chronteltype = 1;
2559 #endif
2560                 } else if(ivideo->chip < SIS_661) {
2561 #ifdef CONFIG_FB_SIS_315
2562                         switch (reg) {
2563                            case SIS310_EXTERNAL_CHIP_LVDS:
2564                                 ivideo->vbflags |= VB_LVDS;
2565                                 break;
2566                            case SIS310_EXTERNAL_CHIP_LVDS_CHRONTEL:
2567                                 ivideo->vbflags |= (VB_LVDS | VB_CHRONTEL);
2568                                 break;
2569                         }
2570                         if(ivideo->vbflags & VB_CHRONTEL) ivideo->chronteltype = 2;
2571 #endif
2572                 } else if(ivideo->chip >= SIS_661) {
2573 #ifdef CONFIG_FB_SIS_315
2574                         inSISIDXREG(SISCR, 0x38, reg);
2575                         reg >>= 5;
2576                         switch(reg) {
2577                            case 0x02:
2578                                 ivideo->vbflags |= VB_LVDS;
2579                                 break;
2580                            case 0x03:
2581                                 ivideo->vbflags |= (VB_LVDS | VB_CHRONTEL);
2582                                 break;
2583                            case 0x04:
2584                                 ivideo->vbflags |= (VB_LVDS | VB_CONEXANT);
2585                                 break;
2586                         }
2587                         if(ivideo->vbflags & VB_CHRONTEL) ivideo->chronteltype = 2;
2588 #endif
2589                 }
2590                 if(ivideo->vbflags & VB_LVDS) {
2591                    printk(KERN_INFO "%s LVDS transmitter\n", stdstr);
2592                 }
2593                 if(ivideo->vbflags & VB_TRUMPION) {
2594                    printk(KERN_INFO "%s Trumpion Zurac LCD scaler\n", stdstr);
2595                 }
2596                 if(ivideo->vbflags & VB_CHRONTEL) {
2597                    printk(KERN_INFO "%s Chrontel TV encoder\n", stdstr);
2598                 }
2599                 if(ivideo->vbflags & VB_CONEXANT) {
2600                    printk(KERN_INFO "%s Conexant external device\n", stdstr);
2601                 }
2602         }
2603
2604         if(ivideo->vbflags & VB_SISBRIDGE) {
2605                 SiS_Sense30x(ivideo);
2606         } else if(ivideo->vbflags & VB_CHRONTEL) {
2607                 SiS_SenseCh(ivideo);
2608         }
2609 }
2610
2611 /* ------------------ Sensing routines ------------------ */
2612
2613 static BOOLEAN __devinit sisfb_test_DDC1(struct sis_video_info *ivideo)
2614 {
2615     unsigned short old;
2616     int count = 48;
2617
2618     old = SiS_ReadDDC1Bit(&ivideo->SiS_Pr);
2619     do {
2620         if(old != SiS_ReadDDC1Bit(&ivideo->SiS_Pr)) break;
2621     } while(count--);
2622     return (count == -1) ? FALSE : TRUE;
2623 }
2624
2625 static void __devinit sisfb_sense_crt1(struct sis_video_info *ivideo)
2626 {
2627     BOOLEAN mustwait = FALSE;
2628     u8  SR1F, CR17;
2629 #ifdef CONFIG_FB_SIS_315
2630     u8  CR63=0;
2631 #endif
2632     u16 temp = 0xffff;
2633     int i;
2634
2635     inSISIDXREG(SISSR,0x1F,SR1F);
2636     orSISIDXREG(SISSR,0x1F,0x04);
2637     andSISIDXREG(SISSR,0x1F,0x3F);
2638     if(SR1F & 0xc0) mustwait = TRUE;
2639
2640 #ifdef CONFIG_FB_SIS_315
2641     if(ivideo->sisvga_engine == SIS_315_VGA) {
2642        inSISIDXREG(SISCR,ivideo->SiS_Pr.SiS_MyCR63,CR63);
2643        CR63 &= 0x40;
2644        andSISIDXREG(SISCR,ivideo->SiS_Pr.SiS_MyCR63,0xBF);
2645     }
2646 #endif
2647
2648     inSISIDXREG(SISCR,0x17,CR17);
2649     CR17 &= 0x80;
2650     if(!CR17) {
2651        orSISIDXREG(SISCR,0x17,0x80);
2652        mustwait = TRUE;
2653        outSISIDXREG(SISSR, 0x00, 0x01);
2654        outSISIDXREG(SISSR, 0x00, 0x03);
2655     }
2656
2657     if(mustwait) {
2658        for(i=0; i < 10; i++) sisfbwaitretracecrt1(ivideo);
2659     }
2660
2661 #ifdef CONFIG_FB_SIS_315
2662     if(ivideo->chip >= SIS_330) {
2663        andSISIDXREG(SISCR,0x32,~0x20);
2664        if(ivideo->chip >= SIS_340) {
2665           outSISIDXREG(SISCR, 0x57, 0x4a);
2666        } else {
2667           outSISIDXREG(SISCR, 0x57, 0x5f);
2668        }
2669        orSISIDXREG(SISCR, 0x53, 0x02);
2670        while((inSISREG(SISINPSTAT)) & 0x01)    break;
2671        while(!((inSISREG(SISINPSTAT)) & 0x01)) break;
2672        if((inSISREG(SISMISCW)) & 0x10) temp = 1;
2673        andSISIDXREG(SISCR, 0x53, 0xfd);
2674        andSISIDXREG(SISCR, 0x57, 0x00);
2675     }
2676 #endif
2677
2678     if(temp == 0xffff) {
2679        i = 3;
2680        do {
2681           temp = SiS_HandleDDC(&ivideo->SiS_Pr, ivideo->vbflags, ivideo->sisvga_engine, 0, 0, NULL);
2682        } while(((temp == 0) || (temp == 0xffff)) && i--);
2683
2684        if((temp == 0) || (temp == 0xffff)) {
2685           if(sisfb_test_DDC1(ivideo)) temp = 1;
2686        }
2687     }
2688
2689     if((temp) && (temp != 0xffff)) {
2690        orSISIDXREG(SISCR,0x32,0x20);
2691     }
2692
2693 #ifdef CONFIG_FB_SIS_315
2694     if(ivideo->sisvga_engine == SIS_315_VGA) {
2695        setSISIDXREG(SISCR,ivideo->SiS_Pr.SiS_MyCR63,0xBF,CR63);
2696     }
2697 #endif
2698
2699     setSISIDXREG(SISCR,0x17,0x7F,CR17);
2700
2701     outSISIDXREG(SISSR,0x1F,SR1F);
2702 }
2703
2704 /* Determine and detect attached devices on SiS30x */
2705 static int __devinit SISDoSense(struct sis_video_info *ivideo, u16 type, u16 test)
2706 {
2707     int temp, mytest, result, i, j;
2708
2709     for(j = 0; j < 10; j++) {
2710        result = 0;
2711        for(i = 0; i < 3; i++) {
2712           mytest = test;
2713           outSISIDXREG(SISPART4,0x11,(type & 0x00ff));
2714           temp = (type >> 8) | (mytest & 0x00ff);
2715           setSISIDXREG(SISPART4,0x10,0xe0,temp);
2716           SiS_DDC2Delay(&ivideo->SiS_Pr, 0x1500);
2717           mytest >>= 8;
2718           mytest &= 0x7f;
2719           inSISIDXREG(SISPART4,0x03,temp);
2720           temp ^= 0x0e;
2721           temp &= mytest;
2722           if(temp == mytest) result++;
2723 #if 1
2724           outSISIDXREG(SISPART4,0x11,0x00);
2725           andSISIDXREG(SISPART4,0x10,0xe0);
2726           SiS_DDC2Delay(&ivideo->SiS_Pr, 0x1000);
2727 #endif
2728        }
2729        if((result == 0) || (result >= 2)) break;
2730     }
2731     return(result);
2732 }
2733
2734 static void __devinit SiS_Sense30x(struct sis_video_info *ivideo)
2735 {
2736     u8  backupP4_0d,backupP2_00,backupP2_4d,backupSR_1e,biosflag=0;
2737     u16 svhs=0, svhs_c=0;
2738     u16 cvbs=0, cvbs_c=0;
2739     u16 vga2=0, vga2_c=0;
2740     int myflag, result;
2741     char stdstr[] = "sisfb: Detected";
2742     char tvstr[]  = "TV connected to";
2743
2744     if(ivideo->vbflags & VB_301) {
2745        svhs = 0x00b9; cvbs = 0x00b3; vga2 = 0x00d1;
2746        inSISIDXREG(SISPART4,0x01,myflag);
2747        if(myflag & 0x04) {
2748           svhs = 0x00dd; cvbs = 0x00ee; vga2 = 0x00fd;
2749        }
2750     } else if(ivideo->vbflags & (VB_301B | VB_302B)) {
2751        svhs = 0x016b; cvbs = 0x0174; vga2 = 0x0190;
2752     } else if(ivideo->vbflags & (VB_301LV | VB_302LV)) {
2753        svhs = 0x0200; cvbs = 0x0100;
2754     } else if(ivideo->vbflags & (VB_301C | VB_302ELV)) {
2755        svhs = 0x016b; cvbs = 0x0110; vga2 = 0x0190;
2756     } else return;
2757
2758     vga2_c = 0x0e08; svhs_c = 0x0404; cvbs_c = 0x0804;
2759     if(ivideo->vbflags & (VB_301LV|VB_302LV|VB_302ELV)) {
2760        svhs_c = 0x0408; cvbs_c = 0x0808;
2761     }
2762     biosflag = 2;
2763
2764     if(ivideo->chip == SIS_300) {
2765        inSISIDXREG(SISSR,0x3b,myflag);
2766        if(!(myflag & 0x01)) vga2 = vga2_c = 0;
2767     }
2768
2769     inSISIDXREG(SISSR,0x1e,backupSR_1e);
2770     orSISIDXREG(SISSR,0x1e,0x20);
2771
2772     inSISIDXREG(SISPART4,0x0d,backupP4_0d);
2773     if(ivideo->vbflags & VB_301C) {
2774        setSISIDXREG(SISPART4,0x0d,~0x07,0x01);
2775     } else {
2776        orSISIDXREG(SISPART4,0x0d,0x04);
2777     }
2778     SiS_DDC2Delay(&ivideo->SiS_Pr, 0x2000);
2779
2780     inSISIDXREG(SISPART2,0x00,backupP2_00);
2781     outSISIDXREG(SISPART2,0x00,((backupP2_00 | 0x1c) & 0xfc));
2782
2783     inSISIDXREG(SISPART2,0x4d,backupP2_4d);
2784     if(ivideo->vbflags & (VB_301C|VB_301LV|VB_302LV|VB_302ELV)) {
2785        outSISIDXREG(SISPART2,0x4d,(backupP2_4d & ~0x10));
2786     }
2787
2788     if(!(ivideo->vbflags & VB_301C)) {
2789        SISDoSense(ivideo, 0, 0);
2790     }
2791
2792     andSISIDXREG(SISCR, 0x32, ~0x14);
2793
2794     if(vga2_c || vga2) {
2795        if(SISDoSense(ivideo, vga2, vga2_c)) {
2796           if(biosflag & 0x01) {
2797              printk(KERN_INFO "%s %s SCART output\n", stdstr, tvstr);
2798              orSISIDXREG(SISCR, 0x32, 0x04);
2799           } else {
2800              printk(KERN_INFO "%s secondary VGA connection\n", stdstr);
2801              orSISIDXREG(SISCR, 0x32, 0x10);
2802           }
2803        }
2804     }
2805
2806     andSISIDXREG(SISCR, 0x32, 0x3f);
2807
2808     if(ivideo->vbflags & VB_301C) {
2809        orSISIDXREG(SISPART4,0x0d,0x04);
2810     }
2811
2812     if((ivideo->sisvga_engine == SIS_315_VGA) &&
2813        (ivideo->vbflags & (VB_301C|VB_301LV|VB_302LV|VB_302ELV))) {
2814        outSISIDXREG(SISPART2,0x4d,(backupP2_4d | 0x10));
2815        SiS_DDC2Delay(&ivideo->SiS_Pr, 0x2000);
2816        if((result = SISDoSense(ivideo, svhs, 0x0604))) {
2817           if((result = SISDoSense(ivideo, cvbs, 0x0804))) {
2818              printk(KERN_INFO "%s %s YPbPr component output\n", stdstr, tvstr);
2819              orSISIDXREG(SISCR,0x32,0x80);
2820           }
2821        }
2822        outSISIDXREG(SISPART2,0x4d,backupP2_4d);
2823     }
2824
2825     andSISIDXREG(SISCR, 0x32, ~0x03);
2826
2827     if(!(ivideo->vbflags & TV_YPBPR)) {
2828        if((result = SISDoSense(ivideo, svhs, svhs_c))) {
2829           printk(KERN_INFO "%s %s SVIDEO output\n", stdstr, tvstr);
2830           orSISIDXREG(SISCR, 0x32, 0x02);
2831        }
2832        if((biosflag & 0x02) || (!result)) {
2833           if(SISDoSense(ivideo, cvbs, cvbs_c)) {
2834              printk(KERN_INFO "%s %s COMPOSITE output\n", stdstr, tvstr);
2835              orSISIDXREG(SISCR, 0x32, 0x01);
2836           }
2837        }
2838     }
2839
2840     SISDoSense(ivideo, 0, 0);
2841
2842     outSISIDXREG(SISPART2,0x00,backupP2_00);
2843     outSISIDXREG(SISPART4,0x0d,backupP4_0d);
2844     outSISIDXREG(SISSR,0x1e,backupSR_1e);
2845
2846     if(ivideo->vbflags & VB_301C) {
2847        inSISIDXREG(SISPART2,0x00,biosflag);
2848        if(biosflag & 0x20) {
2849           for(myflag = 2; myflag > 0; myflag--) {
2850              biosflag ^= 0x20;
2851              outSISIDXREG(SISPART2,0x00,biosflag);
2852           }
2853        }
2854     }
2855
2856     outSISIDXREG(SISPART2,0x00,backupP2_00);
2857 }
2858
2859 /* Determine and detect attached TV's on Chrontel */
2860 static void __devinit SiS_SenseCh(struct sis_video_info *ivideo)
2861 {
2862 #if defined(CONFIG_FB_SIS_300) || defined(CONFIG_FB_SIS_315)
2863     u8 temp1, temp2;
2864     char stdstr[] = "sisfb: Chrontel: Detected TV connected to";
2865 #endif
2866 #ifdef CONFIG_FB_SIS_300
2867     unsigned char test[3];
2868     int i;
2869 #endif
2870
2871     if(ivideo->chip < SIS_315H) {
2872
2873 #ifdef CONFIG_FB_SIS_300
2874        ivideo->SiS_Pr.SiS_IF_DEF_CH70xx = 1;            /* Chrontel 700x */
2875        SiS_SetChrontelGPIO(&ivideo->SiS_Pr, 0x9c);      /* Set general purpose IO for Chrontel communication */
2876        SiS_DDC2Delay(&ivideo->SiS_Pr, 1000);
2877        temp1 = SiS_GetCH700x(&ivideo->SiS_Pr, 0x25);
2878        /* See Chrontel TB31 for explanation */
2879        temp2 = SiS_GetCH700x(&ivideo->SiS_Pr, 0x0e);
2880        if(((temp2 & 0x07) == 0x01) || (temp2 & 0x04)) {
2881           SiS_SetCH700x(&ivideo->SiS_Pr, 0x0b0e);
2882           SiS_DDC2Delay(&ivideo->SiS_Pr, 300);
2883        }
2884        temp2 = SiS_GetCH700x(&ivideo->SiS_Pr, 0x25);
2885        if(temp2 != temp1) temp1 = temp2;
2886
2887        if((temp1 >= 0x22) && (temp1 <= 0x50)) {
2888            /* Read power status */
2889            temp1 = SiS_GetCH700x(&ivideo->SiS_Pr, 0x0e);
2890            if((temp1 & 0x03) != 0x03) {
2891                 /* Power all outputs */
2892                 SiS_SetCH700x(&ivideo->SiS_Pr, 0x0B0E);
2893                 SiS_DDC2Delay(&ivideo->SiS_Pr, 300);
2894            }
2895            /* Sense connected TV devices */
2896            for(i = 0; i < 3; i++) {
2897                SiS_SetCH700x(&ivideo->SiS_Pr, 0x0110);
2898                SiS_DDC2Delay(&ivideo->SiS_Pr, 0x96);
2899                SiS_SetCH700x(&ivideo->SiS_Pr, 0x0010);
2900                SiS_DDC2Delay(&ivideo->SiS_Pr, 0x96);
2901                temp1 = SiS_GetCH700x(&ivideo->SiS_Pr, 0x10);
2902                if(!(temp1 & 0x08))       test[i] = 0x02;
2903                else if(!(temp1 & 0x02))  test[i] = 0x01;
2904                else                      test[i] = 0;
2905                SiS_DDC2Delay(&ivideo->SiS_Pr, 0x96);
2906            }
2907
2908            if(test[0] == test[1])      temp1 = test[0];
2909            else if(test[0] == test[2]) temp1 = test[0];
2910            else if(test[1] == test[2]) temp1 = test[1];
2911            else {
2912                 printk(KERN_INFO
2913                         "sisfb: TV detection unreliable - test results varied\n");
2914                 temp1 = test[2];
2915            }
2916            if(temp1 == 0x02) {
2917                 printk(KERN_INFO "%s SVIDEO output\n", stdstr);
2918                 ivideo->vbflags |= TV_SVIDEO;
2919                 orSISIDXREG(SISCR, 0x32, 0x02);
2920                 andSISIDXREG(SISCR, 0x32, ~0x05);
2921            } else if (temp1 == 0x01) {
2922                 printk(KERN_INFO "%s CVBS output\n", stdstr);
2923                 ivideo->vbflags |= TV_AVIDEO;
2924                 orSISIDXREG(SISCR, 0x32, 0x01);
2925                 andSISIDXREG(SISCR, 0x32, ~0x06);
2926            } else {
2927                 SiS_SetCH70xxANDOR(&ivideo->SiS_Pr, 0x010E,0xF8);
2928                 andSISIDXREG(SISCR, 0x32, ~0x07);
2929            }
2930        } else if(temp1 == 0) {
2931           SiS_SetCH70xxANDOR(&ivideo->SiS_Pr, 0x010E,0xF8);
2932           andSISIDXREG(SISCR, 0x32, ~0x07);
2933        }
2934        /* Set general purpose IO for Chrontel communication */
2935        SiS_SetChrontelGPIO(&ivideo->SiS_Pr, 0x00);
2936 #endif
2937
2938     } else {
2939
2940 #ifdef CONFIG_FB_SIS_315
2941         ivideo->SiS_Pr.SiS_IF_DEF_CH70xx = 2;           /* Chrontel 7019 */
2942         temp1 = SiS_GetCH701x(&ivideo->SiS_Pr, 0x49);
2943         SiS_SetCH701x(&ivideo->SiS_Pr, 0x2049);
2944         SiS_DDC2Delay(&ivideo->SiS_Pr, 0x96);
2945         temp2 = SiS_GetCH701x(&ivideo->SiS_Pr, 0x20);
2946         temp2 |= 0x01;
2947         SiS_SetCH701x(&ivideo->SiS_Pr, (temp2 << 8) | 0x20);
2948         SiS_DDC2Delay(&ivideo->SiS_Pr, 0x96);
2949         temp2 ^= 0x01;
2950         SiS_SetCH701x(&ivideo->SiS_Pr, (temp2 << 8) | 0x20);
2951         SiS_DDC2Delay(&ivideo->SiS_Pr, 0x96);
2952         temp2 = SiS_GetCH701x(&ivideo->SiS_Pr, 0x20);
2953         SiS_SetCH701x(&ivideo->SiS_Pr, (temp1 << 8) | 0x49);
2954         temp1 = 0;
2955         if(temp2 & 0x02) temp1 |= 0x01;
2956         if(temp2 & 0x10) temp1 |= 0x01;
2957         if(temp2 & 0x04) temp1 |= 0x02;
2958         if( (temp1 & 0x01) && (temp1 & 0x02) ) temp1 = 0x04;
2959         switch(temp1) {
2960         case 0x01:
2961              printk(KERN_INFO "%s CVBS output\n", stdstr);
2962              ivideo->vbflags |= TV_AVIDEO;
2963              orSISIDXREG(SISCR, 0x32, 0x01);
2964              andSISIDXREG(SISCR, 0x32, ~0x06);
2965              break;
2966         case 0x02:
2967              printk(KERN_INFO "%s SVIDEO output\n", stdstr);
2968              ivideo->vbflags |= TV_SVIDEO;
2969              orSISIDXREG(SISCR, 0x32, 0x02);
2970              andSISIDXREG(SISCR, 0x32, ~0x05);
2971              break;
2972         case 0x04:
2973              printk(KERN_INFO "%s SCART output\n", stdstr);
2974              orSISIDXREG(SISCR, 0x32, 0x04);
2975              andSISIDXREG(SISCR, 0x32, ~0x03);
2976              break;
2977         default:
2978              andSISIDXREG(SISCR, 0x32, ~0x07);
2979         }
2980 #endif
2981     }
2982 }
2983
2984 /* ------------------------ Heap routines -------------------------- */
2985
2986 static u32 __devinit
2987 sisfb_getheapstart(struct sis_video_info *ivideo)
2988 {
2989         u32 ret = ivideo->sisfb_parm_mem * 1024;
2990         u32 max = ivideo->video_size - ivideo->hwcursor_size;
2991         u32 def;
2992
2993         /* Calculate heap start = end of memory for console
2994          *
2995          * CCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDDDDDHHHHQQQQQQQQQQ
2996          * C = console, D = heap, H = HWCursor, Q = cmd-queue
2997          *
2998          * Basically given by "mem" parameter
2999          *
3000          * maximum = videosize - cmd_queue - hwcursor
3001          *           (results in a heap of size 0)
3002          * default = SiS 300: depends on videosize
3003          *           SiS 315/330: 32k below max
3004          */
3005
3006         if(ivideo->sisvga_engine == SIS_300_VGA) {
3007            max -= TURBO_QUEUE_AREA_SIZE;
3008            if(ivideo->video_size > 0x1000000) {
3009               def = 0xc00000;
3010            } else if(ivideo->video_size > 0x800000) {
3011               def = 0x800000;
3012            } else {
3013               def = 0x400000;
3014            }
3015         } else {
3016            max -= COMMAND_QUEUE_AREA_SIZE;
3017            def = max - 0x8000;
3018         }
3019
3020         if((!ret) || (ret > max) || (ivideo->cardnumber != 0)) {
3021            ret = def;
3022         }
3023
3024         return ret;
3025 }
3026
3027 static int __devinit
3028 sisfb_heap_init(struct sis_video_info *ivideo)
3029 {
3030      SIS_OH *poh;
3031
3032      ivideo->heapstart = ivideo->sisfb_mem = sisfb_getheapstart(ivideo);
3033
3034      ivideo->sisfb_heap_start = ivideo->video_vbase + ivideo->heapstart;
3035      ivideo->sisfb_heap_end   = ivideo->video_vbase + ivideo->video_size;
3036
3037      /* Initialize command queue (We use MMIO only) */
3038
3039 #ifdef CONFIG_FB_SIS_315
3040      if(ivideo->sisvga_engine == SIS_315_VGA) {
3041         u32 tempq = 0;
3042         u8  temp = 0;
3043
3044         ivideo->sisfb_heap_end -= COMMAND_QUEUE_AREA_SIZE;
3045
3046         outSISIDXREG(SISSR, IND_SIS_CMDQUEUE_THRESHOLD, COMMAND_QUEUE_THRESHOLD);
3047         outSISIDXREG(SISSR, IND_SIS_CMDQUEUE_SET, SIS_CMD_QUEUE_RESET);
3048
3049         tempq = MMIO_IN32(ivideo->mmio_vbase, MMIO_QUEUE_READPORT);
3050         MMIO_OUT32(ivideo->mmio_vbase, MMIO_QUEUE_WRITEPORT, tempq);
3051
3052         temp = SIS_CMD_QUEUE_SIZE_512k;
3053         temp |= (SIS_MMIO_CMD_ENABLE | SIS_CMD_AUTO_CORR);
3054         outSISIDXREG(SISSR, IND_SIS_CMDQUEUE_SET, temp);
3055
3056         tempq = (u32)(ivideo->video_size - COMMAND_QUEUE_AREA_SIZE);
3057         MMIO_OUT32(ivideo->mmio_vbase, MMIO_QUEUE_PHYBASE, tempq);
3058
3059         ivideo->caps |= MMIO_CMD_QUEUE_CAP;
3060      }
3061 #endif
3062
3063 #ifdef CONFIG_FB_SIS_300
3064      if(ivideo->sisvga_engine == SIS_300_VGA) {
3065         unsigned long tqueue_pos;
3066         u8 tq_state;
3067
3068         ivideo->sisfb_heap_end -= TURBO_QUEUE_AREA_SIZE;
3069
3070         tqueue_pos = (ivideo->video_size - TURBO_QUEUE_AREA_SIZE) / (64 * 1024);
3071
3072         inSISIDXREG(SISSR, IND_SIS_TURBOQUEUE_SET, tq_state);
3073         tq_state |= 0xf0;
3074         tq_state &= 0xfc;
3075         tq_state |= (u8)(tqueue_pos >> 8);
3076         outSISIDXREG(SISSR, IND_SIS_TURBOQUEUE_SET, tq_state);
3077
3078         outSISIDXREG(SISSR, IND_SIS_TURBOQUEUE_ADR, (u8)(tqueue_pos & 0xff));
3079
3080         ivideo->caps |= TURBO_QUEUE_CAP;
3081      }
3082 #endif
3083
3084      /* Reserve memory for the HWCursor */
3085      ivideo->sisfb_heap_end -= ivideo->hwcursor_size;
3086      ivideo->hwcursor_vbase = ivideo->sisfb_heap_end;
3087      ivideo->caps |= HW_CURSOR_CAP;
3088
3089      ivideo->sisfb_heap_size = ivideo->sisfb_heap_end - ivideo->sisfb_heap_start;
3090
3091      if(ivideo->cardnumber == 0) {
3092
3093         printk(KERN_INFO "sisfb: Memory heap starting at %dK, size %dK\n",
3094                 (int)(ivideo->heapstart / 1024), (int)(ivideo->sisfb_heap_size / 1024));
3095
3096         sisfb_heap.vinfo = ivideo;
3097
3098         sisfb_heap.poha_chain = NULL;
3099         sisfb_heap.poh_freelist = NULL;
3100
3101         poh = sisfb_poh_new_node();
3102         if(poh == NULL) return 1;
3103
3104         poh->poh_next = &sisfb_heap.oh_free;
3105         poh->poh_prev = &sisfb_heap.oh_free;
3106         poh->size = ivideo->sisfb_heap_size;
3107         poh->offset = ivideo->heapstart;
3108
3109         sisfb_heap.oh_free.poh_next = poh;
3110         sisfb_heap.oh_free.poh_prev = poh;
3111         sisfb_heap.oh_free.size = 0;
3112         sisfb_heap.max_freesize = poh->size;
3113
3114         sisfb_heap.oh_used.poh_next = &sisfb_heap.oh_used;
3115         sisfb_heap.oh_used.poh_prev = &sisfb_heap.oh_used;
3116         sisfb_heap.oh_used.size = SENTINEL;
3117
3118      } else {
3119
3120         printk(KERN_INFO "Skipped heap initialization for secondary cards\n");
3121
3122      }
3123
3124      return 0;
3125 }
3126
3127 static SIS_OH *
3128 sisfb_poh_new_node(void)
3129 {
3130         int           i;
3131         unsigned long cOhs;
3132         SIS_OHALLOC   *poha;
3133         SIS_OH        *poh;
3134
3135         if(sisfb_heap.poh_freelist == NULL) {
3136                 poha = kmalloc(SIS_OH_ALLOC_SIZE, GFP_KERNEL);
3137                 if(!poha) return NULL;
3138
3139                 poha->poha_next = sisfb_heap.poha_chain;
3140                 sisfb_heap.poha_chain = poha;
3141
3142                 cOhs = (SIS_OH_ALLOC_SIZE - sizeof(SIS_OHALLOC)) / sizeof(SIS_OH) + 1;
3143
3144                 poh = &poha->aoh[0];
3145                 for(i = cOhs - 1; i != 0; i--) {
3146                         poh->poh_next = poh + 1;
3147                         poh = poh + 1;
3148                 }
3149
3150                 poh->poh_next = NULL;
3151                 sisfb_heap.poh_freelist = &poha->aoh[0];
3152         }
3153
3154         poh = sisfb_heap.poh_freelist;
3155         sisfb_heap.poh_freelist = poh->poh_next;
3156
3157         return (poh);
3158 }
3159
3160 static SIS_OH *
3161 sisfb_poh_allocate(u32 size)
3162 {
3163         SIS_OH *pohThis;
3164         SIS_OH *pohRoot;
3165         int     bAllocated = 0;
3166
3167         if(size > sisfb_heap.max_freesize) {
3168                 DPRINTK("sisfb: Can't allocate %dk video memory\n",
3169                         (unsigned int) size / 1024);
3170                 return (NULL);
3171         }
3172
3173         pohThis = sisfb_heap.oh_free.poh_next;
3174
3175         while(pohThis != &sisfb_heap.oh_free) {
3176                 if (size <= pohThis->size) {
3177                         bAllocated = 1;
3178                         break;
3179                 }
3180                 pohThis = pohThis->poh_next;
3181         }
3182
3183         if(!bAllocated) {
3184                 DPRINTK("sisfb: Can't allocate %dk video memory\n",
3185                         (unsigned int) size / 1024);
3186                 return (NULL);
3187         }
3188
3189         if(size == pohThis->size) {
3190                 pohRoot = pohThis;
3191                 sisfb_delete_node(pohThis);
3192         } else {
3193                 pohRoot = sisfb_poh_new_node();
3194
3195                 if(pohRoot == NULL) {
3196                         return (NULL);
3197                 }
3198
3199                 pohRoot->offset = pohThis->offset;
3200                 pohRoot->size = size;
3201
3202                 pohThis->offset += size;
3203                 pohThis->size -= size;
3204         }
3205
3206         sisfb_heap.max_freesize -= size;
3207
3208         pohThis = &sisfb_heap.oh_used;
3209         sisfb_insert_node(pohThis, pohRoot);
3210
3211         return (pohRoot);
3212 }
3213
3214 static void
3215 sisfb_delete_node(SIS_OH *poh)
3216 {
3217         SIS_OH *poh_prev;
3218         SIS_OH *poh_next;
3219
3220         poh_prev = poh->poh_prev;
3221         poh_next = poh->poh_next;
3222
3223         poh_prev->poh_next = poh_next;
3224         poh_next->poh_prev = poh_prev;
3225 }
3226
3227 static void
3228 sisfb_insert_node(SIS_OH *pohList, SIS_OH *poh)
3229 {
3230         SIS_OH *pohTemp;
3231
3232         pohTemp = pohList->poh_next;
3233
3234         pohList->poh_next = poh;
3235         pohTemp->poh_prev = poh;
3236
3237         poh->poh_prev = pohList;
3238         poh->poh_next = pohTemp;
3239 }
3240
3241 static SIS_OH *
3242 sisfb_poh_free(u32 base)
3243 {
3244         SIS_OH *pohThis;
3245         SIS_OH *poh_freed;
3246         SIS_OH *poh_prev;
3247         SIS_OH *poh_next;
3248         u32     ulUpper;
3249         u32     ulLower;
3250         int     foundNode = 0;
3251
3252         poh_freed = sisfb_heap.oh_used.poh_next;
3253
3254         while(poh_freed != &sisfb_heap.oh_used) {
3255                 if(poh_freed->offset == base) {
3256                         foundNode = 1;
3257                         break;
3258                 }
3259
3260                 poh_freed = poh_freed->poh_next;
3261         }
3262
3263         if(!foundNode) return(NULL);
3264
3265         sisfb_heap.max_freesize += poh_freed->size;
3266
3267         poh_prev = poh_next = NULL;
3268         ulUpper = poh_freed->offset + poh_freed->size;
3269         ulLower = poh_freed->offset;
3270
3271         pohThis = sisfb_heap.oh_free.poh_next;
3272
3273         while(pohThis != &sisfb_heap.oh_free) {
3274                 if(pohThis->offset == ulUpper) {
3275                         poh_next = pohThis;
3276                 } else if((pohThis->offset + pohThis->size) == ulLower) {
3277                         poh_prev = pohThis;
3278                 }
3279                 pohThis = pohThis->poh_next;
3280         }
3281
3282         sisfb_delete_node(poh_freed);
3283
3284         if(poh_prev && poh_next) {
3285                 poh_prev->size += (poh_freed->size + poh_next->size);
3286                 sisfb_delete_node(poh_next);
3287                 sisfb_free_node(poh_freed);
3288                 sisfb_free_node(poh_next);
3289                 return(poh_prev);
3290         }
3291
3292         if(poh_prev) {
3293                 poh_prev->size += poh_freed->size;
3294                 sisfb_free_node(poh_freed);
3295                 return(poh_prev);
3296         }
3297
3298         if(poh_next) {
3299                 poh_next->size += poh_freed->size;
3300                 poh_next->offset = poh_freed->offset;
3301                 sisfb_free_node(poh_freed);
3302                 return(poh_next);
3303         }
3304
3305         sisfb_insert_node(&sisfb_heap.oh_free, poh_freed);
3306
3307         return(poh_freed);
3308 }
3309
3310 static void
3311 sisfb_free_node(SIS_OH *poh)
3312 {
3313         if(poh == NULL) return;
3314
3315         poh->poh_next = sisfb_heap.poh_freelist;
3316         sisfb_heap.poh_freelist = poh;
3317 }
3318
3319 void
3320 sis_malloc(struct sis_memreq *req)
3321 {
3322         struct sis_video_info *ivideo = sisfb_heap.vinfo;
3323         SIS_OH *poh = NULL;
3324
3325         if((ivideo) && (!ivideo->havenoheap)) {
3326            poh = sisfb_poh_allocate((u32)req->size);
3327         }
3328
3329         if(poh == NULL) {
3330            req->offset = req->size = 0;
3331            DPRINTK("sisfb: Video RAM allocation failed\n");
3332         } else {
3333            req->offset = poh->offset;
3334            req->size = poh->size;
3335            DPRINTK("sisfb: Video RAM allocation succeeded: 0x%lx\n",
3336                     (poh->offset + ivideo->video_vbase));
3337         }
3338 }
3339
3340 /* sis_free: u32 because "base" is offset inside video ram, can never be >4GB */
3341
3342 void
3343 sis_free(u32 base)
3344 {
3345         struct sis_video_info *ivideo = sisfb_heap.vinfo;
3346         SIS_OH *poh;
3347
3348         if((!ivideo) || (ivideo->havenoheap)) return;
3349
3350         poh = sisfb_poh_free((u32)base);
3351
3352         if(poh == NULL) {
3353                 DPRINTK("sisfb: sisfb_poh_free() failed at base 0x%x\n",
3354                         (unsigned int) base);
3355         }
3356 }
3357
3358 /* --------------------- SetMode routines ------------------------- */
3359
3360 static void
3361 sisfb_pre_setmode(struct sis_video_info *ivideo)
3362 {
3363         u8 cr30 = 0, cr31 = 0, cr33 = 0, cr35 = 0, cr38 = 0;
3364         int tvregnum = 0;
3365
3366         ivideo->currentvbflags &= (VB_VIDEOBRIDGE | VB_DISPTYPE_DISP2);
3367
3368         inSISIDXREG(SISCR, 0x31, cr31);
3369         cr31 &= ~0x60;
3370         cr31 |= 0x04;
3371
3372         cr33 = ivideo->rate_idx & 0x0F;
3373
3374 #ifdef CONFIG_FB_SIS_315
3375         if(ivideo->sisvga_engine == SIS_315_VGA) {
3376            if(ivideo->chip >= SIS_661) {
3377               inSISIDXREG(SISCR, 0x38, cr38);
3378               cr38 &= ~0x07;  /* Clear LCDA/DualEdge and YPbPr bits */
3379            } else {
3380               tvregnum = 0x38;
3381               inSISIDXREG(SISCR, tvregnum, cr38);
3382               cr38 &= ~0x3b;  /* Clear LCDA/DualEdge and YPbPr bits */
3383            }
3384         }
3385 #endif
3386 #ifdef CONFIG_FB_SIS_300
3387         if(ivideo->sisvga_engine == SIS_300_VGA) {
3388            tvregnum = 0x35;
3389            inSISIDXREG(SISCR, tvregnum, cr38);
3390         }
3391 #endif
3392
3393         SiS_SetEnableDstn(&ivideo->SiS_Pr, FALSE);
3394         SiS_SetEnableFstn(&ivideo->SiS_Pr, FALSE);
3395
3396         switch(ivideo->currentvbflags & VB_DISPTYPE_DISP2) {
3397
3398            case CRT2_TV:
3399               cr38 &= ~0xc0;   /* Clear PAL-M / PAL-N bits */
3400               if((ivideo->vbflags & TV_YPBPR) && (ivideo->vbflags & (VB_301C|VB_301LV|VB_302LV))) {
3401 #ifdef CONFIG_FB_SIS_315
3402                  if(ivideo->chip >= SIS_661) {
3403                     cr38 |= 0x04;
3404                     if(ivideo->vbflags & TV_YPBPR525P)       cr35 |= 0x20;
3405                     else if(ivideo->vbflags & TV_YPBPR750P)  cr35 |= 0x40;
3406                     else if(ivideo->vbflags & TV_YPBPR1080I) cr35 |= 0x60;
3407                     cr30 |= SIS_SIMULTANEOUS_VIEW_ENABLE;
3408                     cr35 &= ~0x01;
3409                     ivideo->currentvbflags |= (TV_YPBPR | (ivideo->vbflags & TV_YPBPRALL));
3410                  } else if(ivideo->sisvga_engine == SIS_315_VGA) {
3411                     cr30 |= (0x80 | SIS_SIMULTANEOUS_VIEW_ENABLE);
3412                     cr38 |= 0x08;
3413                     if(ivideo->vbflags & TV_YPBPR525P)       cr38 |= 0x10;
3414                     else if(ivideo->vbflags & TV_YPBPR750P)  cr38 |= 0x20;
3415                     else if(ivideo->vbflags & TV_YPBPR1080I) cr38 |= 0x30;
3416                     cr31 &= ~0x01;
3417                     ivideo->currentvbflags |= (TV_YPBPR | (ivideo->vbflags & TV_YPBPRALL));
3418                  }
3419 #endif
3420               } else if((ivideo->vbflags & TV_HIVISION) && (ivideo->vbflags & (VB_301|VB_301B|VB_302B))) {
3421                  if(ivideo->chip >= SIS_661) {
3422                     cr38 |= 0x04;
3423                     cr35 |= 0x60;
3424                  } else {
3425                     cr30 |= 0x80;
3426                  }
3427                  cr30 |= SIS_SIMULTANEOUS_VIEW_ENABLE;
3428                  cr31 |= 0x01;
3429                  cr35 |= 0x01;
3430                  ivideo->currentvbflags |= TV_HIVISION;
3431               } else if(ivideo->vbflags & TV_SCART) {
3432                  cr30 = (SIS_VB_OUTPUT_SCART | SIS_SIMULTANEOUS_VIEW_ENABLE);
3433                  cr31 |= 0x01;
3434                  cr35 |= 0x01;
3435                  ivideo->currentvbflags |= TV_SCART;
3436               } else {
3437                  if(ivideo->vbflags & TV_SVIDEO) {
3438                     cr30 = (SIS_VB_OUTPUT_SVIDEO | SIS_SIMULTANEOUS_VIEW_ENABLE);
3439                     ivideo->currentvbflags |= TV_SVIDEO;
3440                  }
3441                  if(ivideo->vbflags & TV_AVIDEO) {
3442                     cr30 = (SIS_VB_OUTPUT_COMPOSITE | SIS_SIMULTANEOUS_VIEW_ENABLE);
3443                     ivideo->currentvbflags |= TV_AVIDEO;
3444                  }
3445               }
3446               cr31 |= SIS_DRIVER_MODE;
3447
3448               if(ivideo->vbflags & (TV_AVIDEO|TV_SVIDEO)) {
3449                  if(ivideo->vbflags & TV_PAL) {
3450                     cr31 |= 0x01; cr35 |= 0x01;
3451                     ivideo->currentvbflags |= TV_PAL;
3452                     if(ivideo->vbflags & TV_PALM) {
3453                        cr38 |= 0x40; cr35 |= 0x04;
3454                        ivideo->currentvbflags |= TV_PALM;
3455                     } else if(ivideo->vbflags & TV_PALN) {
3456                        cr38 |= 0x80; cr35 |= 0x08;
3457                        ivideo->currentvbflags |= TV_PALN;
3458                     }
3459                  } else {
3460                     cr31 &= ~0x01; cr35 &= ~0x01;
3461                     ivideo->currentvbflags |= TV_NTSC;
3462                     if(ivideo->vbflags & TV_NTSCJ) {
3463                        cr38 |= 0x40; cr35 |= 0x02;
3464                        ivideo->currentvbflags |= TV_NTSCJ;
3465                     }
3466                  }
3467               }
3468               break;
3469
3470            case CRT2_LCD:
3471               cr30  = (SIS_VB_OUTPUT_LCD | SIS_SIMULTANEOUS_VIEW_ENABLE);
3472               cr31 |= SIS_DRIVER_MODE;
3473               SiS_SetEnableDstn(&ivideo->SiS_Pr, ivideo->sisfb_dstn);
3474               SiS_SetEnableFstn(&ivideo->SiS_Pr, ivideo->sisfb_fstn);
3475               break;
3476
3477            case CRT2_VGA:
3478               cr30 = (SIS_VB_OUTPUT_CRT2 | SIS_SIMULTANEOUS_VIEW_ENABLE);
3479               cr31 |= SIS_DRIVER_MODE;
3480               if(ivideo->sisfb_nocrt2rate) {
3481                  cr33 |= (sisbios_mode[ivideo->sisfb_mode_idx].rate_idx << 4);
3482               } else {
3483                  cr33 |= ((ivideo->rate_idx & 0x0F) << 4);
3484               }
3485               break;
3486
3487            default:     /* disable CRT2 */
3488               cr30 = 0x00;
3489               cr31 |= (SIS_DRIVER_MODE | SIS_VB_OUTPUT_DISABLE);
3490         }
3491
3492         outSISIDXREG(SISCR, 0x30, cr30);
3493         outSISIDXREG(SISCR, 0x33, cr33);
3494
3495         if(ivideo->chip >= SIS_661) {
3496 #ifdef CONFIG_FB_SIS_315
3497            cr31 &= ~0x01;                          /* Clear PAL flag (now in CR35) */
3498            setSISIDXREG(SISCR, 0x35, ~0x10, cr35); /* Leave overscan bit alone */
3499            cr38 &= 0x07;                           /* Use only LCDA and HiVision/YPbPr bits */
3500            setSISIDXREG(SISCR, 0x38, 0xf8, cr38);
3501 #endif
3502         } else if(ivideo->chip != SIS_300) {
3503            outSISIDXREG(SISCR, tvregnum, cr38);
3504         }
3505         outSISIDXREG(SISCR, 0x31, cr31);
3506
3507         if(ivideo->accel) sisfb_syncaccel(ivideo);
3508
3509         ivideo->SiS_Pr.SiS_UseOEM = ivideo->sisfb_useoem;
3510 }
3511
3512 /* Fix SR11 for 661 and later */
3513 #ifdef CONFIG_FB_SIS_315
3514 static void
3515 sisfb_fixup_SR11(struct sis_video_info *ivideo)
3516 {
3517     u8  tmpreg;
3518
3519     if(ivideo->chip >= SIS_661) {
3520        inSISIDXREG(SISSR,0x11,tmpreg);
3521        if(tmpreg & 0x20) {
3522           inSISIDXREG(SISSR,0x3e,tmpreg);
3523           tmpreg = (tmpreg + 1) & 0xff;
3524           outSISIDXREG(SISSR,0x3e,tmpreg);
3525           inSISIDXREG(SISSR,0x11,tmpreg);
3526        }
3527        if(tmpreg & 0xf0) {
3528           andSISIDXREG(SISSR,0x11,0x0f);
3529        }
3530     }
3531 }
3532 #endif
3533
3534 static void sisfb_set_TVxposoffset(struct sis_video_info *ivideo, int val)
3535 {
3536    if(val > 32) val = 32;
3537    if(val < -32) val = -32;
3538    ivideo->tvxpos = val;
3539
3540    if(ivideo->sisfblocked) return;
3541    if(!ivideo->modechanged) return;
3542
3543    if(ivideo->currentvbflags & CRT2_TV) {
3544
3545       if(ivideo->vbflags & VB_CHRONTEL) {
3546
3547          int x = ivideo->tvx;
3548
3549          switch(ivideo->chronteltype) {
3550          case 1:
3551              x += val;
3552              if(x < 0) x = 0;
3553              outSISIDXREG(SISSR,0x05,0x86);
3554              SiS_SetCH700x(&ivideo->SiS_Pr, (((x & 0xff) << 8) | 0x0a));
3555              SiS_SetCH70xxANDOR(&ivideo->SiS_Pr, (((x & 0x0100) << 1) | 0x08),0xFD);
3556              break;
3557          case 2:
3558              /* Not supported by hardware */
3559              break;
3560          }
3561
3562       } else if(ivideo->vbflags & VB_SISBRIDGE) {
3563
3564          u8 p2_1f,p2_20,p2_2b,p2_42,p2_43;
3565          unsigned short temp;
3566
3567          p2_1f = ivideo->p2_1f;
3568          p2_20 = ivideo->p2_20;
3569          p2_2b = ivideo->p2_2b;
3570          p2_42 = ivideo->p2_42;
3571          p2_43 = ivideo->p2_43;
3572
3573          temp = p2_1f | ((p2_20 & 0xf0) << 4);
3574          temp += (val * 2);
3575          p2_1f = temp & 0xff;
3576          p2_20 = (temp & 0xf00) >> 4;
3577          p2_2b = ((p2_2b & 0x0f) + (val * 2)) & 0x0f;
3578          temp = p2_43 | ((p2_42 & 0xf0) << 4);
3579          temp += (val * 2);
3580          p2_43 = temp & 0xff;
3581          p2_42 = (temp & 0xf00) >> 4;
3582          outSISIDXREG(SISPART2,0x1f,p2_1f);
3583          setSISIDXREG(SISPART2,0x20,0x0F,p2_20);
3584          setSISIDXREG(SISPART2,0x2b,0xF0,p2_2b);
3585          setSISIDXREG(SISPART2,0x42,0x0F,p2_42);
3586          outSISIDXREG(SISPART2,0x43,p2_43);
3587       }
3588    }
3589 }
3590
3591 static void sisfb_set_TVyposoffset(struct sis_video_info *ivideo, int val)
3592 {
3593    if(val > 32) val = 32;
3594    if(val < -32) val = -32;
3595    ivideo->tvypos = val;
3596
3597    if(ivideo->sisfblocked) return;
3598    if(!ivideo->modechanged) return;
3599
3600    if(ivideo->currentvbflags & CRT2_TV) {
3601
3602       if(ivideo->vbflags & VB_CHRONTEL) {
3603
3604          int y = ivideo->tvy;
3605
3606          switch(ivideo->chronteltype) {
3607          case 1:
3608             y -= val;
3609             if(y < 0) y = 0;
3610             outSISIDXREG(SISSR,0x05,0x86);
3611             SiS_SetCH700x(&ivideo->SiS_Pr, (((y & 0xff) << 8) | 0x0b));
3612             SiS_SetCH70xxANDOR(&ivideo->SiS_Pr, ((y & 0x0100) | 0x08),0xFE);
3613             break;
3614          case 2:
3615             /* Not supported by hardware */
3616             break;
3617          }
3618
3619       } else if(ivideo->vbflags & VB_SISBRIDGE) {
3620
3621          char p2_01, p2_02;
3622          val /= 2;
3623          p2_01 = ivideo->p2_01;
3624          p2_02 = ivideo->p2_02;
3625
3626          p2_01 += val;
3627          p2_02 += val;
3628          while((p2_01 <= 0) || (p2_02 <= 0)) {
3629             p2_01 += 2;
3630             p2_02 += 2;
3631          }
3632          outSISIDXREG(SISPART2,0x01,p2_01);
3633          outSISIDXREG(SISPART2,0x02,p2_02);
3634       }
3635    }
3636 }
3637
3638 static void
3639 sisfb_post_setmode(struct sis_video_info *ivideo)
3640 {
3641         BOOLEAN crt1isoff = FALSE;
3642         BOOLEAN doit = TRUE;
3643 #if defined(CONFIG_FB_SIS_300) || defined(CONFIG_FB_SIS_315)
3644         u8 reg;
3645 #endif
3646 #ifdef CONFIG_FB_SIS_315
3647         u8 reg1;
3648 #endif
3649
3650         outSISIDXREG(SISSR,0x05,0x86);
3651
3652 #ifdef CONFIG_FB_SIS_315
3653         sisfb_fixup_SR11(ivideo);
3654 #endif
3655
3656         /* Now we actually HAVE changed the display mode */
3657         ivideo->modechanged = 1;
3658
3659         /* We can't switch off CRT1 if bridge is in slave mode */
3660         if(ivideo->vbflags & VB_VIDEOBRIDGE) {
3661                 if(sisfb_bridgeisslave(ivideo)) doit = FALSE;
3662         } else ivideo->sisfb_crt1off = 0;
3663
3664 #ifdef CONFIG_FB_SIS_300
3665         if(ivideo->sisvga_engine == SIS_300_VGA) {
3666            if((ivideo->sisfb_crt1off) && (doit)) {
3667                 crt1isoff = TRUE;
3668                 reg = 0x00;
3669            } else {
3670                 crt1isoff = FALSE;
3671                 reg = 0x80;
3672            }
3673            setSISIDXREG(SISCR, 0x17, 0x7f, reg);
3674         }
3675 #endif
3676 #ifdef CONFIG_FB_SIS_315
3677         if(ivideo->sisvga_engine == SIS_315_VGA) {
3678            if((ivideo->sisfb_crt1off) && (doit)) {
3679                 crt1isoff = TRUE;
3680                 reg  = 0x40;
3681                 reg1 = 0xc0;
3682            } else {
3683                 crt1isoff = FALSE;
3684                 reg  = 0x00;
3685                 reg1 = 0x00;
3686
3687            }
3688            setSISIDXREG(SISCR, ivideo->SiS_Pr.SiS_MyCR63, ~0x40, reg);
3689            setSISIDXREG(SISSR, 0x1f, ~0xc0, reg1);
3690         }
3691 #endif
3692
3693         if(crt1isoff) {
3694            ivideo->currentvbflags &= ~VB_DISPTYPE_CRT1;
3695            ivideo->currentvbflags |= VB_SINGLE_MODE;
3696         } else {
3697            ivideo->currentvbflags |= VB_DISPTYPE_CRT1;
3698            if(ivideo->currentvbflags & VB_DISPTYPE_CRT2) {
3699                 ivideo->currentvbflags |= VB_MIRROR_MODE;
3700            } else {
3701                 ivideo->currentvbflags |= VB_SINGLE_MODE;
3702            }
3703         }
3704
3705         andSISIDXREG(SISSR, IND_SIS_RAMDAC_CONTROL, ~0x04);
3706
3707         if(ivideo->currentvbflags & CRT2_TV) {
3708            if(ivideo->vbflags & VB_SISBRIDGE) {
3709               inSISIDXREG(SISPART2,0x1f,ivideo->p2_1f);
3710               inSISIDXREG(SISPART2,0x20,ivideo->p2_20);
3711               inSISIDXREG(SISPART2,0x2b,ivideo->p2_2b);
3712               inSISIDXREG(SISPART2,0x42,ivideo->p2_42);
3713               inSISIDXREG(SISPART2,0x43,ivideo->p2_43);
3714               inSISIDXREG(SISPART2,0x01,ivideo->p2_01);
3715               inSISIDXREG(SISPART2,0x02,ivideo->p2_02);
3716            } else if(ivideo->vbflags & VB_CHRONTEL) {
3717               if(ivideo->chronteltype == 1) {
3718                  ivideo->tvx = SiS_GetCH700x(&ivideo->SiS_Pr, 0x0a);
3719                  ivideo->tvx |= (((SiS_GetCH700x(&ivideo->SiS_Pr, 0x08) & 0x02) >> 1) << 8);
3720                  ivideo->tvy = SiS_GetCH700x(&ivideo->SiS_Pr, 0x0b);
3721                  ivideo->tvy |= ((SiS_GetCH700x(&ivideo->SiS_Pr, 0x08) & 0x01) << 8);
3722               }
3723            }
3724         }
3725
3726         if(ivideo->tvxpos) {
3727            sisfb_set_TVxposoffset(ivideo, ivideo->tvxpos);
3728         }
3729         if(ivideo->tvypos) {
3730            sisfb_set_TVyposoffset(ivideo, ivideo->tvypos);
3731         }
3732
3733         if((ivideo->currentvbflags & CRT2_TV) && (ivideo->vbflags & VB_301)) {  /* Set filter for SiS301 */
3734
3735                 unsigned char filter_tb = 0;
3736
3737                 switch (ivideo->video_width) {
3738                    case 320:
3739                         filter_tb = (ivideo->vbflags & TV_NTSC) ? 4 : 12;
3740                         break;
3741                    case 640:
3742                         filter_tb = (ivideo->vbflags & TV_NTSC) ? 5 : 13;
3743                         break;
3744                    case 720:
3745                         filter_tb = (ivideo->vbflags & TV_NTSC) ? 6 : 14;
3746                         break;
3747                    case 400:
3748                    case 800:
3749                         filter_tb = (ivideo->vbflags & TV_NTSC) ? 7 : 15;
3750                         break;
3751                    default:
3752                         ivideo->sisfb_filter = -1;
3753                         break;
3754                 }
3755
3756                 orSISIDXREG(SISPART1, ivideo->CRT2_write_enable, 0x01);
3757
3758                 if(ivideo->vbflags & TV_NTSC) {
3759
3760                         andSISIDXREG(SISPART2, 0x3a, 0x1f);
3761
3762                         if (ivideo->vbflags & TV_SVIDEO) {
3763
3764                                 andSISIDXREG(SISPART2, 0x30, 0xdf);
3765
3766                         } else if (ivideo->vbflags & TV_AVIDEO) {
3767
3768                                 orSISIDXREG(SISPART2, 0x30, 0x20);
3769
3770                                 switch (ivideo->video_width) {
3771                                 case 640:
3772                                         outSISIDXREG(SISPART2, 0x35, 0xEB);
3773                                         outSISIDXREG(SISPART2, 0x36, 0x04);
3774                                         outSISIDXREG(SISPART2, 0x37, 0x25);
3775                                         outSISIDXREG(SISPART2, 0x38, 0x18);
3776                                         break;
3777                                 case 720:
3778                                         outSISIDXREG(SISPART2, 0x35, 0xEE);
3779                                         outSISIDXREG(SISPART2, 0x36, 0x0C);
3780                                         outSISIDXREG(SISPART2, 0x37, 0x22);
3781                                         outSISIDXREG(SISPART2, 0x38, 0x08);
3782                                         break;
3783                                 case 400:
3784                                 case 800:
3785                                         outSISIDXREG(SISPART2, 0x35, 0xEB);
3786                                         outSISIDXREG(SISPART2, 0x36, 0x15);
3787                                         outSISIDXREG(SISPART2, 0x37, 0x25);
3788                                         outSISIDXREG(SISPART2, 0x38, 0xF6);
3789                                         break;
3790                                 }
3791                         }
3792
3793                 } else if(ivideo->vbflags & TV_PAL) {
3794
3795                         andSISIDXREG(SISPART2, 0x3A, 0x1F);
3796
3797                         if (ivideo->vbflags & TV_SVIDEO) {
3798
3799                                 andSISIDXREG(SISPART2, 0x30, 0xDF);
3800
3801                         } else if (ivideo->vbflags & TV_AVIDEO) {
3802
3803                                 orSISIDXREG(SISPART2, 0x30, 0x20);
3804
3805                                 switch (ivideo->video_width) {
3806                                 case 640:
3807                                         outSISIDXREG(SISPART2, 0x35, 0xF1);
3808                                         outSISIDXREG(SISPART2, 0x36, 0xF7);
3809                                         outSISIDXREG(SISPART2, 0x37, 0x1F);
3810                                         outSISIDXREG(SISPART2, 0x38, 0x32);
3811                                         break;
3812                                 case 720:
3813                                         outSISIDXREG(SISPART2, 0x35, 0xF3);
3814                                         outSISIDXREG(SISPART2, 0x36, 0x00);
3815                                         outSISIDXREG(SISPART2, 0x37, 0x1D);
3816                                         outSISIDXREG(SISPART2, 0x38, 0x20);
3817                                         break;
3818                                 case 400:
3819                                 case 800:
3820                                         outSISIDXREG(SISPART2, 0x35, 0xFC);
3821                                         outSISIDXREG(SISPART2, 0x36, 0xFB);
3822                                         outSISIDXREG(SISPART2, 0x37, 0x14);
3823                                         outSISIDXREG(SISPART2, 0x38, 0x2A);
3824                                         break;
3825                                 }
3826                         }
3827                 }
3828
3829                 if((ivideo->sisfb_filter >= 0) && (ivideo->sisfb_filter <= 7)) {
3830                    outSISIDXREG(SISPART2,0x35,(sis_TV_filter[filter_tb].filter[ivideo->sisfb_filter][0]));
3831                    outSISIDXREG(SISPART2,0x36,(sis_TV_filter[filter_tb].filter[ivideo->sisfb_filter][1]));
3832                    outSISIDXREG(SISPART2,0x37,(sis_TV_filter[filter_tb].filter[ivideo->sisfb_filter][2]));
3833                    outSISIDXREG(SISPART2,0x38,(sis_TV_filter[filter_tb].filter[ivideo->sisfb_filter][3]));
3834                 }
3835
3836         }
3837 }
3838
3839 #ifndef MODULE
3840 int __init sisfb_setup(char *options)
3841 {
3842         char *this_opt;
3843
3844         sisfb_setdefaultparms();
3845
3846         printk(KERN_DEBUG "sisfb: Options %s\n", options);
3847
3848         if(!options || !(*options)) {
3849                 return 0;
3850         }
3851
3852         while((this_opt = strsep(&options, ",")) != NULL) {
3853
3854                 if(!(*this_opt)) continue;
3855
3856                 if(!strnicmp(this_opt, "off", 3)) {
3857                         sisfb_off = 1;
3858                 } else if(!strnicmp(this_opt, "forcecrt2type:", 14)) {
3859                         /* Need to check crt2 type first for fstn/dstn */
3860                         sisfb_search_crt2type(this_opt + 14);
3861                 } else if(!strnicmp(this_opt, "tvmode:",7)) {
3862                         sisfb_search_tvstd(this_opt + 7);
3863                 } else if(!strnicmp(this_opt, "tvstandard:",11)) {
3864                         sisfb_search_tvstd(this_opt + 7);
3865                 } else if(!strnicmp(this_opt, "mode:", 5)) {
3866                         sisfb_search_mode(this_opt + 5, FALSE);
3867                 } else if(!strnicmp(this_opt, "vesa:", 5)) {
3868                         sisfb_search_vesamode(simple_strtoul(this_opt + 5, NULL, 0), FALSE);
3869 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
3870                 } else if(!strnicmp(this_opt, "inverse", 7)) {
3871                         sisfb_inverse = 1;
3872                         /* fb_invert_cmaps(); */
3873                 } else if(!strnicmp(this_opt, "font:", 5)) {
3874                         if(strlen(this_opt + 5) < 40) {
3875                            strncpy(sisfb_fontname, this_opt + 5, sizeof(sisfb_fontname) - 1);
3876                            sisfb_fontname[sizeof(sisfb_fontname) - 1] = '\0';
3877                         }
3878 #endif
3879                 } else if(!strnicmp(this_opt, "rate:", 5)) {
3880                         sisfb_parm_rate = simple_strtoul(this_opt + 5, NULL, 0);
3881                 } else if(!strnicmp(this_opt, "filter:", 7)) {
3882                         sisfb_filter = (int)simple_strtoul(this_opt + 7, NULL, 0);
3883                 } else if(!strnicmp(this_opt, "forcecrt1:", 10)) {
3884                         sisfb_forcecrt1 = (int)simple_strtoul(this_opt + 10, NULL, 0);
3885                 } else if(!strnicmp(this_opt, "mem:",4)) {
3886                         sisfb_parm_mem = simple_strtoul(this_opt + 4, NULL, 0);
3887                 } else if(!strnicmp(this_opt, "pdc:", 4)) {
3888                         sisfb_pdc = simple_strtoul(this_opt + 4, NULL, 0);
3889                 } else if(!strnicmp(this_opt, "pdc1:", 5)) {
3890                         sisfb_pdca = simple_strtoul(this_opt + 5, NULL, 0);
3891                 } else if(!strnicmp(this_opt, "noaccel", 7)) {
3892                         sisfb_accel = 0;
3893                 } else if(!strnicmp(this_opt, "accel", 5)) {
3894                         sisfb_accel = -1;
3895                 } else if(!strnicmp(this_opt, "noypan", 6)) {
3896                         sisfb_ypan = 0;
3897                 } else if(!strnicmp(this_opt, "ypan", 4)) {
3898                         sisfb_ypan = -1;
3899                 } else if(!strnicmp(this_opt, "nomax", 5)) {
3900                         sisfb_max = 0;
3901                 } else if(!strnicmp(this_opt, "max", 3)) {
3902                         sisfb_max = -1;
3903                 } else if(!strnicmp(this_opt, "userom:", 7)) {
3904                         sisfb_userom = (int)simple_strtoul(this_opt + 7, NULL, 0);
3905                 } else if(!strnicmp(this_opt, "useoem:", 7)) {
3906                         sisfb_useoem = (int)simple_strtoul(this_opt + 7, NULL, 0);
3907                 } else if(!strnicmp(this_opt, "nocrt2rate", 10)) {
3908                         sisfb_nocrt2rate = 1;
3909                 } else if(!strnicmp(this_opt, "scalelcd:", 9)) {
3910                         unsigned long temp = 2;
3911                         temp = simple_strtoul(this_opt + 9, NULL, 0);
3912                         if((temp == 0) || (temp == 1)) {
3913                            sisfb_scalelcd = temp ^ 1;
3914                         }
3915                 } else if(!strnicmp(this_opt, "tvxposoffset:", 13)) {
3916                         int temp = 0;
3917                         temp = (int)simple_strtol(this_opt + 13, NULL, 0);
3918                         if((temp >= -32) && (temp <= 32)) {
3919                            sisfb_tvxposoffset = temp;
3920                         }
3921                 } else if(!strnicmp(this_opt, "tvyposoffset:", 13)) {
3922                         int temp = 0;
3923                         temp = (int)simple_strtol(this_opt + 13, NULL, 0);
3924                         if((temp >= -32) && (temp <= 32)) {
3925                            sisfb_tvyposoffset = temp;
3926                         }
3927                 } else if(!strnicmp(this_opt, "specialtiming:", 14)) {
3928                         sisfb_search_specialtiming(this_opt + 14);
3929                 } else if(!strnicmp(this_opt, "lvdshl:", 7)) {
3930                         int temp = 4;
3931                         temp = simple_strtoul(this_opt + 7, NULL, 0);
3932                         if((temp >= 0) && (temp <= 3)) {
3933                            sisfb_lvdshl = temp;
3934                         }
3935                 } else if(this_opt[0] >= '0' && this_opt[0] <= '9') {
3936                         sisfb_search_mode(this_opt, TRUE);
3937 #if !defined(__i386__) && !defined(__x86_64__)
3938                 } else if(!strnicmp(this_opt, "resetcard", 9)) {
3939                         sisfb_resetcard = 1;
3940                 } else if(!strnicmp(this_opt, "videoram:", 9)) {
3941                         sisfb_videoram = simple_strtoul(this_opt + 9, NULL, 0);
3942 #endif
3943                 } else {
3944                         printk(KERN_INFO "sisfb: Invalid option %s\n", this_opt);
3945                 }
3946
3947         }
3948
3949
3950
3951         return 0;
3952 }
3953 #endif
3954
3955 static void __iomem * __devinit sis_find_rom(struct pci_dev *pdev)
3956 {
3957         struct sis_video_info *ivideo = pci_get_drvdata(pdev);
3958
3959 #if defined(__i386__) || defined(__x86_64__)
3960         u32  segstart;
3961         void __iomem *rom_base, *rom;
3962         int  romptr;
3963         unsigned short pciid;
3964
3965         for(segstart=0x000c0000; segstart<0x000f0000; segstart+=0x00001000) {
3966
3967             rom_base = ioremap(segstart, 0x10000);
3968             if(!rom_base) continue;
3969
3970             if((readb(rom_base) != 0x55) || (readb(rom_base + 1) != 0xaa)) {
3971                iounmap(rom_base);
3972                continue;
3973             }
3974
3975             romptr = (unsigned short)(readb(rom_base + 0x18) | (readb(rom_base + 0x19) << 8));
3976             if(romptr > (0x10000 - 8)) {
3977                iounmap(rom_base);
3978                continue;
3979             }
3980
3981             rom = rom_base + romptr;
3982
3983             if((readb(rom)     != 'P') || (readb(rom + 1) != 'C') ||
3984                (readb(rom + 2) != 'I') || (readb(rom + 3) != 'R')) {
3985                iounmap(rom_base);
3986                continue;
3987             }
3988
3989             pciid = readb(rom + 4) | (readb(rom + 5) << 8);
3990             if(pciid != 0x1039) {
3991                iounmap(rom_base);
3992                continue;
3993             }
3994
3995             pciid = readb(rom + 6) | (readb(rom + 7) << 8);
3996             if(pciid == ivideo->chip_id) return rom_base;
3997
3998             iounmap(rom_base);
3999         }
4000 #else
4001         void __iomem *rom_base, *rom, *myrombase = NULL;
4002         int  romptr;
4003         unsigned short pciid;
4004         u32 backup;
4005
4006         pci_read_config_dword(pdev, PCI_ROM_ADDRESS, &backup);
4007         pci_write_config_dword(pdev, PCI_ROM_ADDRESS,
4008                         (ivideo->video_base & PCI_ROM_ADDRESS_MASK) | PCI_ROM_ADDRESS_ENABLE);
4009
4010         rom_base = ioremap(ivideo->video_base, 65536);
4011         if(rom_base) {
4012            if((readb(rom_base) == 0x55) && (readb(rom_base + 1) == 0xaa)) {
4013               romptr = (u16)(readb(rom_base + 0x18) | (readb(rom_base + 0x19) << 8));
4014               if(romptr <= (0x10000 - 8)) {
4015                  rom = rom_base + romptr;
4016                  if((readb(rom)     == 'P') && (readb(rom + 1) == 'C') &&
4017                     (readb(rom + 2) == 'I') && (readb(rom + 3) == 'R')) {
4018                     pciid = readb(rom + 4) | (readb(rom + 5) << 8);
4019                     if(pciid == 0x1039) {
4020                        pciid = readb(rom + 6) | (readb(rom + 7) << 8);
4021                        if(pciid == ivideo->chip_id) {
4022                           if((myrombase = vmalloc(65536))) {
4023                              memcpy_fromio(myrombase, rom_base, 65536);
4024                           }
4025                        }
4026                     }
4027                  }
4028               }
4029            }
4030            iounmap(rom_base);
4031         }
4032         pci_write_config_dword(pdev, PCI_ROM_ADDRESS, backup);
4033         if(myrombase) return myrombase;
4034 #endif
4035         return NULL;
4036 }
4037
4038 #ifdef CONFIG_FB_SIS_300
4039 static int __devinit
4040 sisfb_chkbuswidth300(struct pci_dev *pdev, void __iomem *FBAddress)
4041 {
4042         struct sis_video_info *ivideo = pci_get_drvdata(pdev);
4043         int i, j;
4044         USHORT temp;
4045         UCHAR reg;
4046
4047         andSISIDXREG(SISSR,0x15,0xFB);
4048         orSISIDXREG(SISSR,0x15,0x04);
4049         outSISIDXREG(SISSR,0x13,0x00);
4050         outSISIDXREG(SISSR,0x14,0xBF);
4051
4052         for(i=0; i<2; i++) {
4053            temp = 0x1234;
4054            for(j=0; j<4; j++) {
4055               writew(temp, FBAddress);
4056               if(readw(FBAddress) == temp) break;
4057               orSISIDXREG(SISSR,0x3c,0x01);
4058               inSISIDXREG(SISSR,0x05,reg);
4059               inSISIDXREG(SISSR,0x05,reg);
4060               andSISIDXREG(SISSR,0x3c,0xfe);
4061               inSISIDXREG(SISSR,0x05,reg);
4062               inSISIDXREG(SISSR,0x05,reg);
4063               temp++;
4064            }
4065         }
4066
4067         writel(0x01234567L, FBAddress);
4068         writel(0x456789ABL, (FBAddress+4));
4069         writel(0x89ABCDEFL, (FBAddress+8));
4070         writel(0xCDEF0123L, (FBAddress+12));
4071         inSISIDXREG(SISSR,0x3b,reg);
4072         if(reg & 0x01) {
4073            if(readl((FBAddress+12)) == 0xCDEF0123L) return(4);  /* Channel A 128bit */
4074         }
4075         if(readl((FBAddress+4)) == 0x456789ABL)     return(2);  /* Channel B 64bit */
4076         return(1);                                              /* 32bit */
4077 }
4078
4079 static void __devinit
4080 sisfb_setramsize300(struct pci_dev *pdev)
4081 {
4082         struct  sis_video_info *ivideo = pci_get_drvdata(pdev);
4083         void __iomem *FBAddr = ivideo->sishw_ext.pjVideoMemoryAddress, *Addr;
4084         USHORT  SR13, SR14=0, buswidth, Done, data, TotalCapacity, PhysicalAdrOtherPage=0;
4085         int     PseudoRankCapacity, PseudoTotalCapacity, PseudoAdrPinCount;
4086         int     RankCapacity, AdrPinCount, BankNumHigh, BankNumMid, MB2Bank;
4087         int     PageCapacity, PhysicalAdrHigh, PhysicalAdrHalfPage, i, j, k;
4088         const   USHORT SiS_DRAMType[17][5] = {
4089                         {0x0C,0x0A,0x02,0x40,0x39},
4090                         {0x0D,0x0A,0x01,0x40,0x48},
4091                         {0x0C,0x09,0x02,0x20,0x35},
4092                         {0x0D,0x09,0x01,0x20,0x44},
4093                         {0x0C,0x08,0x02,0x10,0x31},
4094                         {0x0D,0x08,0x01,0x10,0x40},
4095                         {0x0C,0x0A,0x01,0x20,0x34},
4096                         {0x0C,0x09,0x01,0x08,0x32},
4097                         {0x0B,0x08,0x02,0x08,0x21},
4098                         {0x0C,0x08,0x01,0x08,0x30},
4099                         {0x0A,0x08,0x02,0x04,0x11},
4100                         {0x0B,0x0A,0x01,0x10,0x28},
4101                         {0x09,0x08,0x02,0x02,0x01},
4102                         {0x0B,0x09,0x01,0x08,0x24},
4103                         {0x0B,0x08,0x01,0x04,0x20},
4104                         {0x0A,0x08,0x01,0x02,0x10},
4105                         {0x09,0x08,0x01,0x01,0x00}
4106                 };
4107
4108         buswidth = sisfb_chkbuswidth300(pdev, FBAddr);
4109
4110         MB2Bank = 16;
4111         Done = 0;
4112         for(i = 6; i >= 0; i--) {
4113            if(Done) break;
4114            PseudoRankCapacity = 1 << i;
4115            for(j = 4; j >= 1; j--) {
4116               if(Done) break;
4117               PseudoTotalCapacity = PseudoRankCapacity * j;
4118               PseudoAdrPinCount = 15 - j;
4119               if(PseudoTotalCapacity <= 64) {
4120                  for(k = 0; k <= 16; k++) {
4121                     if(Done) break;
4122                     RankCapacity = buswidth * SiS_DRAMType[k][3];
4123                     AdrPinCount = SiS_DRAMType[k][2] + SiS_DRAMType[k][0];
4124                     if(RankCapacity == PseudoRankCapacity)
4125                        if(AdrPinCount <= PseudoAdrPinCount) {
4126                           if(j == 3) {             /* Rank No */
4127                              BankNumHigh = RankCapacity * MB2Bank * 3 - 1;
4128                              BankNumMid  = RankCapacity * MB2Bank * 1 - 1;
4129                           } else {
4130                              BankNumHigh = RankCapacity * MB2Bank * j - 1;
4131                              BankNumMid  = RankCapacity * MB2Bank * j / 2 - 1;
4132                           }
4133                           PageCapacity = (1 << SiS_DRAMType[k][1]) * buswidth * 4;
4134                           PhysicalAdrHigh = BankNumHigh;
4135                           PhysicalAdrHalfPage = (PageCapacity / 2 + PhysicalAdrHigh) % PageCapacity;
4136                           PhysicalAdrOtherPage = PageCapacity * SiS_DRAMType[k][2] + PhysicalAdrHigh;
4137                           /* Write data */
4138                           andSISIDXREG(SISSR,0x15,0xFB); /* Test */
4139                           orSISIDXREG(SISSR,0x15,0x04);  /* Test */
4140                           TotalCapacity = SiS_DRAMType[k][3] * buswidth;
4141                           SR13 = SiS_DRAMType[k][4];
4142                           if(buswidth == 4) SR14 = (TotalCapacity - 1) | 0x80;
4143                           if(buswidth == 2) SR14 = (TotalCapacity - 1) | 0x40;
4144                           if(buswidth == 1) SR14 = (TotalCapacity - 1) | 0x00;
4145                           outSISIDXREG(SISSR,0x13,SR13);
4146                           outSISIDXREG(SISSR,0x14,SR14);
4147                           Addr = FBAddr + BankNumHigh * 64 * 1024 + PhysicalAdrHigh;
4148                           /* *((USHORT *)(Addr)) = (USHORT)PhysicalAdrHigh; */
4149                           writew(((USHORT)PhysicalAdrHigh), Addr);
4150                           Addr = FBAddr + BankNumMid * 64 * 1024 + PhysicalAdrHigh;
4151                           /* *((USHORT *)(Addr)) = (USHORT)BankNumMid; */
4152                           writew(((USHORT)BankNumMid), Addr);
4153                           Addr = FBAddr + BankNumHigh * 64 * 1024 + PhysicalAdrHalfPage;
4154                           /* *((USHORT *)(Addr)) = (USHORT)PhysicalAdrHalfPage; */
4155                           writew(((USHORT)PhysicalAdrHalfPage), Addr);
4156                           Addr = FBAddr + BankNumHigh * 64 * 1024 + PhysicalAdrOtherPage;
4157                           /* *((USHORT *)(Addr)) = PhysicalAdrOtherPage; */
4158                           writew(((USHORT)PhysicalAdrOtherPage), Addr);
4159                           /* Read data */
4160                           Addr = FBAddr + BankNumHigh * 64 * 1024 + PhysicalAdrHigh;
4161                           data = readw(Addr); /* *((USHORT *)(Addr)); */
4162                           if(data == PhysicalAdrHigh) Done = 1;
4163                        }  /* if */
4164                  }  /* for k */
4165               }  /* if */
4166            }  /* for j */
4167         }  /* for i */
4168 }
4169
4170 static void __devinit sisfb_post_sis300(struct pci_dev *pdev)
4171 {
4172         struct sis_video_info *ivideo = pci_get_drvdata(pdev);
4173         u8  reg, v1, v2, v3, v4, v5, v6, v7, v8;
4174         u16 index, rindex, memtype = 0;
4175
4176         outSISIDXREG(SISSR,0x05,0x86);
4177
4178         if(ivideo->sishw_ext.UseROM) {
4179            if(ivideo->sishw_ext.pjVirtualRomBase[0x52] & 0x80) {
4180               memtype = ivideo->sishw_ext.pjVirtualRomBase[0x52];
4181            } else {
4182               inSISIDXREG(SISSR,0x3a,memtype);
4183            }
4184            memtype &= 0x07;
4185         }
4186
4187         if(ivideo->revision_id <= 0x13) {
4188            v1 = 0x44; v2 = 0x42; v3 = 0x80;
4189            v4 = 0x44; v5 = 0x42; v6 = 0x80;
4190         } else {
4191            v1 = 0x68; v2 = 0x43; v3 = 0x80;  /* Assume 125Mhz MCLK */
4192            v4 = 0x68; v5 = 0x43; v6 = 0x80;  /* Assume 125Mhz ECLK */
4193            if(ivideo->sishw_ext.UseROM) {
4194               index = memtype * 5;
4195               rindex = index + 0x54;
4196               v1 = ivideo->sishw_ext.pjVirtualRomBase[rindex++];
4197               v2 = ivideo->sishw_ext.pjVirtualRomBase[rindex++];
4198               v3 = ivideo->sishw_ext.pjVirtualRomBase[rindex++];
4199               rindex = index + 0x7c;
4200               v4 = ivideo->sishw_ext.pjVirtualRomBase[rindex++];
4201               v5 = ivideo->sishw_ext.pjVirtualRomBase[rindex++];
4202               v6 = ivideo->sishw_ext.pjVirtualRomBase[rindex++];
4203            }
4204         }
4205         outSISIDXREG(SISSR,0x28,v1);
4206         outSISIDXREG(SISSR,0x29,v2);
4207         outSISIDXREG(SISSR,0x2a,v3);
4208         outSISIDXREG(SISSR,0x2e,v4);
4209         outSISIDXREG(SISSR,0x2f,v5);
4210         outSISIDXREG(SISSR,0x30,v6);
4211         v1 = 0x10;
4212         if(ivideo->sishw_ext.UseROM) v1 = ivideo->sishw_ext.pjVirtualRomBase[0xa4];
4213         outSISIDXREG(SISSR,0x07,v1);       /* DAC speed */
4214         outSISIDXREG(SISSR,0x11,0x0f);     /* DDC, power save */
4215         v1 = 0x01; v2 = 0x43; v3 = 0x1e; v4 = 0x2a;
4216         v5 = 0x06; v6 = 0x00; v7 = 0x00; v8 = 0x00;
4217         if(ivideo->sishw_ext.UseROM) {
4218            memtype += 0xa5;
4219            v1 = ivideo->sishw_ext.pjVirtualRomBase[memtype];
4220            v2 = ivideo->sishw_ext.pjVirtualRomBase[memtype + 8];
4221            v3 = ivideo->sishw_ext.pjVirtualRomBase[memtype + 16];
4222            v4 = ivideo->sishw_ext.pjVirtualRomBase[memtype + 24];
4223            v5 = ivideo->sishw_ext.pjVirtualRomBase[memtype + 32];
4224            v6 = ivideo->sishw_ext.pjVirtualRomBase[memtype + 40];
4225            v7 = ivideo->sishw_ext.pjVirtualRomBase[memtype + 48];
4226            v8 = ivideo->sishw_ext.pjVirtualRomBase[memtype + 56];
4227         }
4228         if(ivideo->revision_id >= 0x80) v3 &= 0xfd;
4229         outSISIDXREG(SISSR,0x15,v1);       /* Ram type (assuming 0, BIOS 0xa5 step 8) */
4230         outSISIDXREG(SISSR,0x16,v2);
4231         outSISIDXREG(SISSR,0x17,v3);
4232         outSISIDXREG(SISSR,0x18,v4);
4233         outSISIDXREG(SISSR,0x19,v5);
4234         outSISIDXREG(SISSR,0x1a,v6);
4235         outSISIDXREG(SISSR,0x1b,v7);
4236         outSISIDXREG(SISSR,0x1c,v8);       /* ---- */
4237         andSISIDXREG(SISSR,0x15,0xfb);
4238         orSISIDXREG(SISSR,0x15,0x04);
4239         if(ivideo->sishw_ext.UseROM) {
4240            if(ivideo->sishw_ext.pjVirtualRomBase[0x53] & 0x02) {
4241               orSISIDXREG(SISSR,0x19,0x20);
4242            }
4243         }
4244         v1 = 0x04;                         /* DAC pedestal (BIOS 0xe5) */
4245         if(ivideo->revision_id >= 0x80) v1 |= 0x01;
4246         outSISIDXREG(SISSR,0x1f,v1);
4247         outSISIDXREG(SISSR,0x20,0xa0);     /* linear & relocated io */
4248         v1 = 0xf6; v2 = 0x0d; v3 = 0x00;
4249         if(ivideo->sishw_ext.UseROM) {
4250            v1 = ivideo->sishw_ext.pjVirtualRomBase[0xe8];
4251            v2 = ivideo->sishw_ext.pjVirtualRomBase[0xe9];
4252            v3 = ivideo->sishw_ext.pjVirtualRomBase[0xea];
4253         }
4254         outSISIDXREG(SISSR,0x23,v1);
4255         outSISIDXREG(SISSR,0x24,v2);
4256         outSISIDXREG(SISSR,0x25,v3);
4257         outSISIDXREG(SISSR,0x21,0x84);
4258         outSISIDXREG(SISSR,0x22,0x00);
4259         outSISIDXREG(SISCR,0x37,0x00);
4260         orSISIDXREG(SISPART1,0x24,0x01);   /* unlock crt2 */
4261         outSISIDXREG(SISPART1,0x00,0x00);
4262         v1 = 0x40; v2 = 0x11;
4263         if(ivideo->sishw_ext.UseROM) {
4264            v1 = ivideo->sishw_ext.pjVirtualRomBase[0xec];
4265            v2 = ivideo->sishw_ext.pjVirtualRomBase[0xeb];
4266         }
4267         outSISIDXREG(SISPART1,0x02,v1);
4268         if(ivideo->revision_id >= 0x80) v2 &= ~0x01;
4269         inSISIDXREG(SISPART4,0x00,reg);
4270         if((reg == 1) || (reg == 2)) {
4271            outSISIDXREG(SISCR,0x37,0x02);
4272            outSISIDXREG(SISPART2,0x00,0x1c);
4273            v4 = 0x00; v5 = 0x00; v6 = 0x10;
4274            if(ivideo->sishw_ext.UseROM) {
4275               v4 = ivideo->sishw_ext.pjVirtualRomBase[0xf5];
4276               v5 = ivideo->sishw_ext.pjVirtualRomBase[0xf6];
4277               v6 = ivideo->sishw_ext.pjVirtualRomBase[0xf7];
4278            }
4279            outSISIDXREG(SISPART4,0x0d,v4);
4280            outSISIDXREG(SISPART4,0x0e,v5);
4281            outSISIDXREG(SISPART4,0x10,v6);
4282            outSISIDXREG(SISPART4,0x0f,0x3f);
4283            inSISIDXREG(SISPART4,0x01,reg);
4284            if(reg >= 0xb0) {
4285               inSISIDXREG(SISPART4,0x23,reg);
4286               reg &= 0x20;
4287               reg <<= 1;
4288               outSISIDXREG(SISPART4,0x23,reg);
4289            }
4290         } else {
4291            v2 &= ~0x10;
4292         }
4293         outSISIDXREG(SISSR,0x32,v2);
4294         andSISIDXREG(SISPART1,0x24,0xfe);  /* Lock CRT2 */
4295         inSISIDXREG(SISSR,0x16,reg);
4296         reg &= 0xc3;
4297         outSISIDXREG(SISCR,0x35,reg);
4298         outSISIDXREG(SISCR,0x83,0x00);
4299 #if !defined(__i386__) && !defined(__x86_64__)
4300         if(sisfb_videoram) {
4301            outSISIDXREG(SISSR,0x13,0x28);  /* ? */
4302            reg = ((sisfb_videoram >> 10) - 1) | 0x40;
4303            outSISIDXREG(SISSR,0x14,reg);
4304         } else {
4305 #endif
4306            /* Need to map max FB size for finding out about RAM size */
4307            ivideo->sishw_ext.pjVideoMemoryAddress = ioremap(ivideo->video_base, 0x4000000);
4308            if(ivideo->sishw_ext.pjVideoMemoryAddress) {
4309               sisfb_setramsize300(pdev);
4310               iounmap(ivideo->sishw_ext.pjVideoMemoryAddress);
4311            } else {
4312               printk(KERN_DEBUG "sisfb: Failed to map memory for size detection, assuming 8MB\n");
4313               outSISIDXREG(SISSR,0x13,0x28);  /* ? */
4314               outSISIDXREG(SISSR,0x14,0x47);  /* 8MB, 64bit default */
4315            }
4316 #if !defined(__i386__) && !defined(__x86_64__)
4317         }
4318 #endif
4319         if(ivideo->sishw_ext.UseROM) {
4320            v1 = ivideo->sishw_ext.pjVirtualRomBase[0xe6];
4321            v2 = ivideo->sishw_ext.pjVirtualRomBase[0xe7];
4322         } else {
4323            inSISIDXREG(SISSR,0x3a,reg);
4324            if((reg & 0x30) == 0x30) {
4325               v1 = 0x04; /* PCI */
4326               v2 = 0x92;
4327            } else {
4328               v1 = 0x14; /* AGP */
4329               v2 = 0xb2;
4330            }
4331         }
4332         outSISIDXREG(SISSR,0x21,v1);
4333         outSISIDXREG(SISSR,0x22,v2);
4334 }
4335 #endif
4336
4337 #ifdef CONFIG_FB_SIS_315
4338 static void __devinit sisfb_post_sis315330(struct pci_dev *pdev)
4339 {
4340 #ifdef YET_TO_BE_DONE
4341         struct sis_video_info *ivideo = pci_get_drvdata(pdev);
4342         u8  reg, v1, v2, v3, v4, v5, v6, v7, v8;
4343         u16 index, rindex, memtype = 0;
4344         u32 reg1_32, reg2_32, reg3_32;
4345         int i;
4346
4347         /* Unlock */
4348         /* outSISIDXREG(0x3c4,0x05,0x86); */
4349         outSISIDXREG(SISSR,0x05,0x86);
4350
4351         /* Enable relocated i/o ports */
4352         /* setSISIDXREG(0x3c4,0x20,~0x10,0x20); */
4353         setSISIDXREG(SISSR,0x20,~0x10,0x20);
4354
4355         /* Clear regs */
4356         for(i = 0; i < 0x22; i++) {
4357            outSISIDXREG(SISSR,(0x06 + i),0x00);
4358         }
4359         v1 = 0x0d;
4360         if( is 330) v1 = 0x0b;
4361         for(i = 0; i < v1; i++) {
4362            outSISIDXREG(SISSR,(0x31 + i),0x00);
4363         }
4364         for(i = 0; i < 0x10; i++) {
4365            outSISIDXREG(SISCR,(0x30 + i),0x00);
4366         }
4367
4368         /* Reset clocks */
4369         reg = inSISREG(SISMISCR);
4370         outSISIDXREG(SISSR,0x28,0x81);
4371         outSISIDXREG(SISSR,0x2A,0x00);
4372         outSISIDXREG(SISSR,0x29,0xE1);
4373         outSISREG(SISMISCW,(reg | 0x0c));
4374         outSISIDXREG(SISSR,0x2B,0x81);
4375         outSISIDXREG(SISSR,0x2D,0x00);
4376         outSISIDXREG(SISSR,0x2C,0xE1);
4377         outSISIDXREG(SISSR,0x2E,0x81);
4378         outSISIDXREG(SISSR,0x30,0x00);
4379         outSISIDXREG(SISSR,0x2F,0xE1);
4380         SiS_DDC2Delay(....);
4381         outSISREG(SISMISCW,reg);
4382
4383         /* Get memory type */
4384         if(ivideo->sishw_ext.UseROM) {
4385            if(ivideo->sishw_ext.pjVirtualRomBase[0x52] & 0x80)) {
4386               memtype = ivideo->sishw_ext.pjVirtualRomBase[0x52];
4387            } else {
4388               inSISIDXREG(SISSR,0x3a,memtype);
4389            }
4390            memtype &= 0x03;
4391            if( is 330 ) {
4392               if(memtype <= 1) memtype = 0;
4393               else {
4394                  inSISIDXREG(SISCR,0x5F,reg);
4395                  reg &= 0x30;
4396                  switch(reg) {
4397                  case 0x00: memtype = 1; break;
4398                  case 0x10: memtype = 3; break;
4399                  case 0x20: memtype = 3; break;
4400                  default:   memtype = 2;
4401                  }
4402               }
4403            }
4404         }
4405
4406         /* Set clocks */
4407         v1 = 0x3b; v2 = 0x22; v3 = 0x01;  /* Assume 143Mhz MCLK */
4408         v4 = 0x5c; v5 = 0x23; v6 = 0x01;  /* Assume 166Mhz ECLK */
4409         if(ivideo->sishw_ext.UseROM) {
4410            index = memtype * 5;
4411            rindex = index + 0x54;
4412            v1 = ivideo->sishw_ext.pjVirtualRomBase[rindex++];
4413            v2 = ivideo->sishw_ext.pjVirtualRomBase[rindex++];
4414            v3 = ivideo->sishw_ext.pjVirtualRomBase[rindex++];
4415            rindex = index + 0x68;
4416            v4 = ivideo->sishw_ext.pjVirtualRomBase[rindex++];
4417            v5 = ivideo->sishw_ext.pjVirtualRomBase[rindex++];
4418            v6 = ivideo->sishw_ext.pjVirtualRomBase[rindex++];
4419         }
4420         outSISIDXREG(SISSR,0x28,v1);
4421         outSISIDXREG(SISSR,0x29,v2);
4422         outSISIDXREG(SISSR,0x2a,v3);
4423         if( is 330 ) {
4424            inSISIDXREG(SISSR,0x3a,reg);
4425            reg &= 0x03;
4426            if(reg >= 2) {
4427               ...
4428            }
4429         }
4430         outSISIDXREG(SISSR,0x2e,v4);
4431         outSISIDXREG(SISSR,0x2f,v5);
4432         outSISIDXREG(SISSR,0x30,v6);
4433
4434         /* End of comp with 330 */
4435
4436         v1 = 0x18;
4437         if(ivideo->sishw_ext.UseROM) v1 = ivideo->sishw_ext.pjVirtualRomBase[0x7c];
4438         outSISIDXREG(SISSR,0x07,v1);
4439         outSISIDXREG(SISSR,0x11,0x0f);
4440
4441         v1 = 0x00; v2 = 0x0f; v3 = 0xba; v4 = 0xa9;
4442         v5 = 0xa0; v6 = 0x00; v7 = 0x30;
4443         if(ivideo->sishw_ext.UseROM) {
4444            index = memtype + 0x7d;
4445            v1 = ivideo->sishw_ext.pjVirtualRomBase[index];
4446            v2 = ivideo->sishw_ext.pjVirtualRomBase[index + 4];
4447            v3 = ivideo->sishw_ext.pjVirtualRomBase[index + 8];
4448            v4 = ivideo->sishw_ext.pjVirtualRomBase[index + 12];
4449            v5 = ivideo->sishw_ext.pjVirtualRomBase[index + 16];
4450            v6 = ivideo->sishw_ext.pjVirtualRomBase[index + 20];
4451            v7 = ivideo->sishw_ext.pjVirtualRomBase[index + 24];
4452         }
4453         outSISIDXREG(SISSR,0x15,v1);       /* Ram type (assuming 0, BIOS 0x7d step 4) */
4454         outSISIDXREG(SISSR,0x16,v2);
4455         outSISIDXREG(SISSR,0x17,v3);
4456         outSISIDXREG(SISSR,0x18,v4);
4457         outSISIDXREG(SISSR,0x19,v5);
4458         outSISIDXREG(SISSR,0x1a,v6);
4459         outSISIDXREG(SISSR,0x1b,v7);
4460         outSISIDXREG(SISSR,0x1c,v8);       /* ---- */
4461
4462         v1 = 0x77; v2 = 0x77; v3 = 0x00; v4 = 0x5b; v5 = 0x00;
4463         if(ivideo->sishw_ext.UseROM) {
4464            index = memtype + 0xa2;
4465            v1 = ivideo->sishw_ext.pjVirtualRomBase[index];
4466            v2 = ivideo->sishw_ext.pjVirtualRomBase[index + 4];
4467            v3 = ivideo->sishw_ext.pjVirtualRomBase[index + 8];
4468            v4 = ivideo->sishw_ext.pjVirtualRomBase[index + 12];
4469            v5 = ivideo->sishw_ext.pjVirtualRomBase[index + 16];
4470         }
4471         outSISIDXREG(SISCR,0x40,v1);
4472         outSISIDXREG(SISCR,0x41,v2);
4473         outSISIDXREG(SISCR,0x42,v3);
4474         outSISIDXREG(SISCR,0x43,v4);
4475         outSISIDXREG(SISCR,0x44,v5);
4476
4477         if( is 330 ) {
4478
4479            v1 = 0x;
4480            if(ivideo->sishw_ext.UseROM) {
4481               v1 = ivideo->sishw_ext.pjVirtualRomBase[0xBA];
4482            }
4483            outSISIDXREG(SISCR,0x59,v1);
4484
4485            v1 = 0x; v2 = 0x; v3 = 0x; v4 = 0x;
4486            v5 = 0x; v6 = 0x; v7 = 0x; v8 = 0x;
4487            if(ivideo->sishw_ext.UseROM) {
4488               index = memtype + 0xbe;
4489               v1 = ivideo->sishw_ext.pjVirtualRomBase[index];
4490               v2 = ivideo->sishw_ext.pjVirtualRomBase[index + 4];
4491               v3 = ivideo->sishw_ext.pjVirtualRomBase[index + 8];
4492               v4 = ivideo->sishw_ext.pjVirtualRomBase[index + 12];
4493               v5 = ivideo->sishw_ext.pjVirtualRomBase[index + 16];
4494               v6 = ivideo->sishw_ext.pjVirtualRomBase[index + 20];
4495               v7 = ivideo->sishw_ext.pjVirtualRomBase[index + 24];
4496               v8 = ivideo->sishw_ext.pjVirtualRomBase[index + 28];
4497            }
4498            outSISIDXREG(SISCR,0x68,v1);
4499            outSISIDXREG(SISCR,0x69,v2);
4500            outSISIDXREG(SISCR,0x6a,v3);
4501            outSISIDXREG(SISCR,0x6b,v4);
4502            outSISIDXREG(SISCR,0x6c,v5);
4503            outSISIDXREG(SISCR,0x6d,v6);
4504            outSISIDXREG(SISCR,0x6e,v7);
4505            outSISIDXREG(SISCR,0x6f,v8);
4506
4507            v1 = 0x20;
4508            inSISIDXREG(SISSR,0x3b,reg);
4509
4510            if(!(reg & 0x04)) {
4511               inSISIDXREG(SISCR,0x5F,reg);
4512               reg &= 0x30;
4513               if(reg) v1 = 0x23;
4514            }
4515            outSISIDXREG(SISCR,0x48,v1);
4516            outSISIDXREG(SISCR,0x4c,0x20);
4517
4518            xx= xxx();
4519            if(xx >= 1) {
4520               v1 = 0x;
4521               if(ivideo->sishw_ext.UseROM) {
4522                  v1 = ivideo->sishw_ext.pjVirtualRomBase[0xBA];
4523               }
4524               outSISIDXREG(SISCR,0x59,v1);
4525            }
4526
4527
4528
4529         } else {
4530
4531            outSISIDXREG(SISCR,0x48,0x23);
4532
4533            andSISIDXREG(SISSR,0x16,0x0f);
4534            if(memtype <= 1) {
4535               orSISIDXREG(SISSR,0x16,0x80);
4536            } else {
4537               v1 = 0x0f;
4538               if(ivideo->sishw_ext.UseROM) {
4539                  v1 = ivideo->sishw_ext.pjVirtualRomBase[0x81 + memtype];
4540               }
4541               if(!(v1 & 0x10)) v2 = 0xc0;
4542               else             v2 = 0xd0;
4543               orSISIDXREG(SISSR,0x16,v2);
4544               andSISIDXREG(SISSR,0x16,0x0f);
4545               if(!(v1 & 0x10)) v2 = 0x80;
4546               else             v2 = 0xA0;
4547               orSISIDXREG(SISSR,0x16,v2);
4548            }
4549
4550            if(memtype >= 2) {
4551               const u8 sr3cseq1[] = { 0xc0,0xe0,0xf0,0xe0,0xf0,0xa0,0xb0,0xa0,0xb0,0x90,0xd0 };
4552               const u8 sr3cseq2[] = { 0xc0,0xa0,0xb0,0xa0,0xb0,0xe0,0xf0,0xa0,0xb0,0x90,0xd0 };
4553               for(i = 0; i < 11; i++) {
4554                  outSISIDXREG(SISSR,0x3c,sr3cseq1[i]);
4555               }
4556               outSISIDXREG(SISSR,0x3d,0x00);
4557               outSISIDXREG(SISSR,0x3d,0x04);
4558               SiS_DDC2Delay(0x200);
4559               v1 = inSISIDXREG(SISCR,0xEC);
4560               v2 = inSISIDXREG(SISCR,0xED);
4561               reg1_32 = (v2 << 8) | v1;
4562               outSISIDXREG(SISSR,0x3D,0x00);
4563               for(i = 0; i < 11; i++) {
4564                  outSISIDXREG(SISSR,0x3c,sr3cseq2[i]);
4565               }
4566               outSISIDXREG(SISSR,0x3d,0x00);
4567               outSISIDXREG(SISSR,0x3d,0x04);
4568               SiS_DDC2Delay(0x200);
4569               v1 = inSISIDXREG(SISCR,0xEC);
4570               v2 = inSISIDXREG(SISCR,0xED);
4571               reg2_32 = (v2 << 8) | v1;
4572               outSISIDXREG(SISSR,0x3D,0x00);
4573               reg3_32 = reg2_32 << 1;
4574               reg2_32 >>= 1;
4575               reg3_32 += reg2_32;
4576               v1 = 0x40;
4577               if(reg3_32 > reg1_32) v1 = 0x10;
4578                  outSISIDXREG(SISCR,0x59,v1);
4579            }
4580
4581         }
4582
4583         v1 = 0x00;
4584         if(ivideo->sishw_ext.UseROM) {
4585            v1 = ivideo->sishw_ext.pjVirtualRomBase[0x99];
4586         }
4587         outSISIDXREG(SISSR,0x1f,v1);
4588
4589         outSISIDXREG(SISSR,0x20,0x20);
4590
4591         v1 = 0xf6; v2 = 0x0d; v3 = 0x33;
4592         if(ivideo->sishw_ext.UseROM) {
4593            v1 = ivideo->sishw_ext.pjVirtualRomBase[0x9c];
4594            v2 = ivideo->sishw_ext.pjVirtualRomBase[0x9d];
4595            v3 = ivideo->sishw_ext.pjVirtualRomBase[0x9e];
4596         }
4597         outSISIDXREG(SISSR,0x23,v1);
4598         outSISIDXREG(SISSR,0x24,v2);
4599         outSISIDXREG(SISSR,0x25,v3);
4600
4601         outSISIDXREG(SISSR,0x21,0x84);
4602         outSISIDXREG(SISSR,0x22,0x00);
4603         outSISIDXREG(SISSR,0x27,0x1f);
4604
4605         v1 = 0x00; v2 = 0x00;
4606         if(ivideo->sishw_ext.UseROM) {
4607            v1 = ivideo->sishw_ext.pjVirtualRomBase[0x9F];
4608            v2 = ivideo->sishw_ext.pjVirtualRomBase[0xA1];
4609         }
4610         outSISIDXREG(SISSR,0x31,v1);
4611         outSISIDXREG(SISSR,0x33,v2);
4612
4613         v1 = 0x11;
4614         if(ivideo->sishw_ext.UseROM) {
4615            v1 = ivideo->sishw_ext.pjVirtualRomBase[0xA0];
4616         }
4617         v2 = inSISIDXREG(SISPART4,0x00);
4618         if((v2 != 1) && (v2 != 2)) v1 &= 0xef;
4619         outSISIDXREG(SISSR,0x32,v1);
4620
4621         /* AGP */
4622         pci_read_config_long(pdev, 0x50, &reg1_32);
4623         reg1_32 >>= 20;
4624         reg1_32 &= 0x0f;
4625         if(reg1_32 == 1) {
4626            v1 = 0xAA; v2 = 0x33;
4627            if(ivideo->sishw_ext.UseROM) {
4628               v1 = ivideo->sishw_ext.pjVirtualRomBase[0xF7];
4629               v2 = ivideo->sishw_ext.pjVirtualRomBase[0x9E];
4630            }
4631         } else {
4632            v1 = 0x88; v2 = 0x03;
4633            if(ivideo->sishw_ext.UseROM) {
4634               v1 = ivideo->sishw_ext.pjVirtualRomBase[0xF8];
4635               v2 = ivideo->sishw_ext.pjVirtualRomBase[0xF6];
4636            }
4637         }
4638         outSISIDXREG(SISCR,0x49,v1);
4639         outSISIDXREG(SISSR,0x25,v2);
4640
4641         v1 = inSISIDXREG(SISPART4,0x00);
4642         if((v1 == 1) || (v1 == 2)) {
4643            orSISIDXREG(SISPART1,0x2F,0x01);  /* Unlock CRT2 */
4644            outSISIDXREG(SISPART1,0x00,0x00);
4645            v1 = 0x00;
4646            if(ivideo->sishw_ext.UseROM) {
4647               v1 = ivideo->sishw_ext.pjVirtualRomBase[0xb6];
4648            }
4649            outSISIDXREG(SISPART1,0x02,v1);
4650            outSISIDXREG(SISPART1,0x2E,0x08);
4651            outSISIDXREG(SISPART2,0x00,0x1c);
4652            v1 = 0x40; v2 = 0x00; v3 = 0x80;
4653            if(ivideo->sishw_ext.UseROM) {
4654               v1 = ivideo->sishw_ext.pjVirtualRomBase[0xb7];
4655               v2 = ivideo->sishw_ext.pjVirtualRomBase[0xb8];
4656               v3 = ivideo->sishw_ext.pjVirtualRomBase[0xbb];
4657            }
4658            outSISIDXREG(SISPART4,0x0d,v1);
4659            outSISIDXREG(SISPART4,0x0e,v2);
4660            outSISIDXREG(SISPART4,0x10,v3);
4661            outSISIDXREG(SISPART4,0x0F,0x3F);
4662
4663            inSISIDXREG(SISPART4,0x01,reg);
4664            if(reg >= 0xb0) {
4665               inSISIDXREG(SISPART4,0x23,reg);
4666               reg &= 0x20;
4667               reg <<= 1;
4668               outSISIDXREG(SISPART4,0x23,reg);
4669            }
4670         }
4671         outSISIDXREG(SISCR,0x37,0x02); /* Why? */
4672
4673         outSISIDXREG(SISCR,0x83,0x00);
4674         outSISIDXREG(SISCR,0x90,0x00);
4675         andSISIDXREG(SISSR,0x5B,0xDF);
4676         outSISIDXREG(SISVID,0x00,0x86);
4677         outSISIDXREG(SISVID,0x32,0x00);
4678         outSISIDXREG(SISVID,0x30,0x00);
4679         outSISIDXREG(SISVID,0x32,0x01);
4680         outSISIDXREG(SISVID,0x30,0x00);
4681         orSISIDXREG(SISCR,0x63,0x80);
4682         /* End of Init1 */
4683
4684         /* Set Mode 0x2e */
4685
4686         /* Ramsize */
4687         orSISIDXREG(SISSR,0x16,0x0f);
4688         orSISIDXREG(SISSR,0x18,0xA9);
4689         orSISIDXREG(SISSR,0x19,0xA0);
4690         orSISIDXREG(SISSR,0x1B,0x30);
4691         andSISIDXREG(SISSR,0x17,0xF8);
4692         orSISIDXREG(SISSR,0x19,0x03);
4693         andSIDIDXREG(SISSR,0x13,0x00);
4694
4695         /* Need to map max FB size for finding out about RAM size */
4696         ivideo->sishw_ext.pjVideoMemoryAddress = ioremap(ivideo->video_base, 0x4000000);
4697         if(ivideo->sishw_ext.pjVideoMemoryAddress) {
4698            /* Find out about bus width */
4699            if(memtype <= 1) {
4700               outSISIDXREG(SISSR,0x14,0x02);
4701               andSISIDXREG(SISSR,0x16,0x0F);
4702               orSISIDXREG(SISSR,0x16,0x80);
4703
4704               ...
4705
4706            } else {
4707
4708               ...
4709
4710            }
4711
4712            /* Find out about size */
4713
4714
4715            iounmap(ivideo->sishw_ext.pjVideoMemoryAddress);
4716         } else {
4717            printk(KERN_DEBUG "sisfb: Failed to map memory for size detection, assuming 8MB\n");
4718            outSISIDXREG(SISSR,0x14,0x??);  /* 8MB, 64bit default */
4719         }
4720
4721         /* AGP (Missing: Checks for VIA and AMD hosts) */
4722         v1 = 0xA5; v2 = 0xFB;
4723         if(ivideo->sishw_ext.UseROM) {
4724            v1 = ivideo->sishw_ext.pjVirtualRomBase[0x9A];
4725            v2 = ivideo->sishw_ext.pjVirtualRomBase[0x9B];
4726         }
4727         outSISIDXREG(SISSR,0x21,v1);
4728         outSISIDXREG(SISSR,0x22,v2);
4729
4730 #endif
4731         return;
4732 }
4733 #endif
4734
4735
4736 int __devinit sisfb_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
4737 {
4738         struct sisfb_chip_info  *chipinfo = &sisfb_chip_info[ent->driver_data];
4739         struct sis_video_info   *ivideo = NULL;
4740         struct fb_info          *sis_fb_info = NULL;
4741         u16 reg16;
4742         u8  reg;
4743         int sisvga_enabled = 0, i;
4744
4745         if(sisfb_off) return -ENXIO;
4746
4747 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,3))
4748         sis_fb_info = framebuffer_alloc(sizeof(*ivideo), &pdev->dev);
4749         if(!sis_fb_info) return -ENOMEM;
4750 #else
4751         sis_fb_info = kmalloc(sizeof(*sis_fb_info) + sizeof(*ivideo), GFP_KERNEL);
4752         if(!sis_fb_info) return -ENOMEM;
4753         memset(sis_fb_info, 0, sizeof(*sis_fb_info) + sizeof(*ivideo));
4754         sis_fb_info->par = ((char *)sis_fb_info + sizeof(*sis_fb_info));
4755 #endif
4756
4757         ivideo = (struct sis_video_info *)sis_fb_info->par;
4758         ivideo->memyselfandi = sis_fb_info;
4759
4760         if(card_list == NULL) {
4761            ivideo->cardnumber = 0;
4762         } else {
4763            struct sis_video_info *countvideo = card_list;
4764            ivideo->cardnumber = 1;
4765            while ((countvideo = countvideo->next) != NULL) ivideo->cardnumber++;
4766         }
4767
4768         strncpy(ivideo->myid, chipinfo->chip_name, 30);
4769
4770         ivideo->chip_id = pdev->device;
4771         pci_read_config_byte(pdev, PCI_REVISION_ID, &ivideo->revision_id);
4772         ivideo->sishw_ext.jChipRevision = ivideo->revision_id;
4773         pci_read_config_word(pdev, PCI_COMMAND, &reg16);
4774         sisvga_enabled = reg16 & 0x01;
4775         ivideo->pcibus = pdev->bus->number;
4776         ivideo->pcislot = PCI_SLOT(pdev->devfn);
4777         ivideo->pcifunc = PCI_FUNC(pdev->devfn);
4778         ivideo->subsysvendor = pdev->subsystem_vendor;
4779         ivideo->subsysdevice = pdev->subsystem_device;
4780 #ifdef SIS_CONFIG_COMPAT
4781         ivideo->ioctl32registered = 0;
4782         ivideo->ioctl32vblankregistered = 0;
4783 #endif
4784
4785 #ifndef MODULE
4786         if(sisfb_mode_idx == -1) {
4787                 sisfb_get_vga_mode_from_kernel();
4788         }
4789 #endif
4790
4791         ivideo->chip = chipinfo->chip;
4792         ivideo->sisvga_engine = chipinfo->vgaengine;
4793         ivideo->hwcursor_size = chipinfo->hwcursor_size;
4794         ivideo->CRT2_write_enable = chipinfo->CRT2_write_enable;
4795         ivideo->mni = chipinfo->mni;
4796
4797         ivideo->detectedpdc  = 0xff;
4798         ivideo->detectedpdca = 0xff;
4799         ivideo->detectedlcda = 0xff;
4800
4801         ivideo->sisfb_thismonitor.datavalid = FALSE;
4802
4803         ivideo->sisfb_parm_mem = sisfb_parm_mem;
4804         ivideo->sisfb_accel = sisfb_accel;
4805         ivideo->sisfb_ypan = sisfb_ypan;
4806         ivideo->sisfb_max = sisfb_max;
4807         ivideo->sisfb_userom = sisfb_userom;
4808         ivideo->sisfb_useoem = sisfb_useoem;
4809         ivideo->sisfb_mode_idx = sisfb_mode_idx;
4810         ivideo->sisfb_parm_rate = sisfb_parm_rate;
4811         ivideo->sisfb_crt1off = sisfb_crt1off;
4812         ivideo->sisfb_forcecrt1 = sisfb_forcecrt1;
4813         ivideo->sisfb_crt2type = sisfb_crt2type;
4814         ivideo->sisfb_crt2flags = sisfb_crt2flags;
4815         /* pdc(a), scalelcd, special timing, lvdshl handled below */
4816         ivideo->sisfb_dstn = sisfb_dstn;
4817         ivideo->sisfb_fstn = sisfb_fstn;
4818         ivideo->sisfb_tvplug = sisfb_tvplug;
4819         ivideo->sisfb_tvstd = sisfb_tvstd;
4820         ivideo->tvxpos = sisfb_tvxposoffset;
4821         ivideo->tvypos = sisfb_tvyposoffset;
4822         ivideo->sisfb_filter = sisfb_filter;
4823         ivideo->sisfb_nocrt2rate = sisfb_nocrt2rate;
4824 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,5,0)
4825         ivideo->sisfb_inverse = sisfb_inverse;
4826 #endif
4827
4828         ivideo->refresh_rate = 0;
4829         if(ivideo->sisfb_parm_rate != -1) {
4830            ivideo->refresh_rate = ivideo->sisfb_parm_rate;
4831         }
4832
4833         ivideo->SiS_Pr.UsePanelScaler = sisfb_scalelcd;
4834         ivideo->SiS_Pr.CenterScreen = -1;
4835         ivideo->SiS_Pr.SiS_CustomT = sisfb_specialtiming;
4836         ivideo->SiS_Pr.LVDSHL = sisfb_lvdshl;
4837
4838         ivideo->SiS_Pr.SiS_Backup70xx = 0xff;
4839         ivideo->SiS_Pr.SiS_CHOverScan = -1;
4840         ivideo->SiS_Pr.SiS_ChSW = FALSE;
4841         ivideo->SiS_Pr.SiS_UseLCDA = FALSE;
4842         ivideo->SiS_Pr.HaveEMI = FALSE;
4843         ivideo->SiS_Pr.HaveEMILCD = FALSE;
4844         ivideo->SiS_Pr.OverruleEMI = FALSE;
4845         ivideo->SiS_Pr.SiS_SensibleSR11 = FALSE;
4846         ivideo->SiS_Pr.SiS_MyCR63 = 0x63;
4847         ivideo->SiS_Pr.PDC  = -1;
4848         ivideo->SiS_Pr.PDCA = -1;
4849 #ifdef CONFIG_FB_SIS_315
4850         if(ivideo->chip >= SIS_330) {
4851            ivideo->SiS_Pr.SiS_MyCR63 = 0x53;
4852            if(ivideo->chip >= SIS_661) {
4853               ivideo->SiS_Pr.SiS_SensibleSR11 = TRUE;
4854            }
4855         }
4856 #endif
4857
4858         memcpy(&ivideo->default_var, &my_default_var, sizeof(my_default_var));
4859
4860         pci_set_drvdata(pdev, ivideo);
4861
4862         /* Patch special cases */
4863         if((ivideo->nbridge = sisfb_get_northbridge(ivideo->chip))) {
4864                 switch(ivideo->nbridge->device) {
4865 #ifdef CONFIG_FB_SIS_300
4866                 case PCI_DEVICE_ID_SI_730:
4867                         ivideo->chip = SIS_730;
4868                         strcpy(ivideo->myid, "SiS 730");
4869                         break;
4870 #endif
4871 #ifdef CONFIG_FB_SIS_315
4872                 case PCI_DEVICE_ID_SI_651:
4873                         /* ivideo->chip is ok */
4874                         strcpy(ivideo->myid, "SiS 651");
4875                         break;
4876                 case PCI_DEVICE_ID_SI_740:
4877                         ivideo->chip = SIS_740;
4878                         strcpy(ivideo->myid, "SiS 740");
4879                         break;
4880                 case PCI_DEVICE_ID_SI_661:
4881                         ivideo->chip = SIS_661;
4882                         strcpy(ivideo->myid, "SiS 661");
4883                         break;
4884                 case PCI_DEVICE_ID_SI_741:
4885                         ivideo->chip = SIS_741;
4886                         strcpy(ivideo->myid, "SiS 741");
4887                         break;
4888                 case PCI_DEVICE_ID_SI_760:
4889                         ivideo->chip = SIS_760;
4890                         strcpy(ivideo->myid, "SiS 760");
4891                         break;
4892 #endif
4893                 }
4894         }
4895
4896 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
4897         strcpy(sis_fb_info->modename, ivideo->myid);
4898 #endif
4899
4900         ivideo->sishw_ext.jChipType = ivideo->chip;
4901
4902 #ifdef CONFIG_FB_SIS_315
4903         if((ivideo->sishw_ext.jChipType == SIS_315PRO) ||
4904            (ivideo->sishw_ext.jChipType == SIS_315)) {
4905                 ivideo->sishw_ext.jChipType = SIS_315H;
4906         }
4907 #endif
4908
4909         ivideo->video_base = pci_resource_start(pdev, 0);
4910         ivideo->mmio_base  = pci_resource_start(pdev, 1);
4911         ivideo->mmio_size  = pci_resource_len(pdev, 1);
4912         ivideo->SiS_Pr.RelIO = pci_resource_start(pdev, 2) + 0x30;
4913         ivideo->sishw_ext.ulIOAddress = ivideo->vga_base = ivideo->SiS_Pr.RelIO;
4914
4915         if(!sisvga_enabled) {
4916                 if(pci_enable_device(pdev)) {
4917                         pci_set_drvdata(pdev, NULL);
4918                         kfree(sis_fb_info);
4919                         return -EIO;
4920                 }
4921         }
4922
4923         SiSRegInit(&ivideo->SiS_Pr, ivideo->sishw_ext.ulIOAddress);
4924
4925 #ifdef CONFIG_FB_SIS_300
4926         /* Find PCI systems for Chrontel/GPIO communication setup */
4927         if(ivideo->chip == SIS_630) {
4928            i=0;
4929            do {
4930               if(mychswtable[i].subsysVendor == ivideo->subsysvendor &&
4931                  mychswtable[i].subsysCard   == ivideo->subsysdevice) {
4932                  ivideo->SiS_Pr.SiS_ChSW = TRUE;
4933                  printk(KERN_DEBUG "sisfb: Identified [%s %s] requiring Chrontel/GPIO setup\n",
4934                         mychswtable[i].vendorName, mychswtable[i].cardName);
4935                  break;
4936               }
4937               i++;
4938            } while(mychswtable[i].subsysVendor != 0);
4939         }
4940 #endif
4941
4942         outSISIDXREG(SISSR, 0x05, 0x86);
4943
4944         if( (!sisvga_enabled)
4945 #if !defined(__i386__) && !defined(__x86_64__)
4946                               || (sisfb_resetcard)
4947 #endif
4948                                                    ) {
4949                 for(i = 0x30; i <= 0x3f; i++) {
4950                         outSISIDXREG(SISCR,i,0x00);
4951                 }
4952         }
4953
4954         /* Find out about current video mode */
4955         inSISIDXREG(SISCR,0x34,reg);
4956         if(reg & 0x7f) {
4957                 ivideo->modeprechange = reg & 0x7f;
4958         } else {
4959                 ivideo->modeprechange = 0x03;
4960 #if defined(__i386__) || defined(__x86_64__)
4961                 {
4962                         unsigned char __iomem *tt = ioremap(0, 0x1000);
4963                         if(tt) {
4964                                 ivideo->modeprechange = tt[0x449];
4965                                 iounmap(tt);
4966                         }
4967                 }
4968 #endif
4969         }
4970
4971 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
4972 #ifdef MODULE
4973         if((reg & 0x80) && (reg != 0xff)) {
4974            if((sisbios_mode[ivideo->sisfb_mode_idx].mode_no[ivideo->mni]) != 0xFF) {
4975               printk(KERN_INFO "sisfb: Cannot initialize display mode, X server is active\n");
4976               pci_set_drvdata(pdev, NULL);
4977               kfree(sis_fb_info);
4978               return -EBUSY;
4979            }
4980         }
4981 #endif
4982 #endif
4983
4984         ivideo->sishw_ext.bIntegratedMMEnabled = TRUE;
4985 #ifdef CONFIG_FB_SIS_300
4986         if(ivideo->sisvga_engine == SIS_300_VGA) {
4987            if(ivideo->chip != SIS_300) {
4988               inSISIDXREG(SISSR, 0x1a, reg);
4989               if(!(reg & 0x10)) {
4990                  ivideo->sishw_ext.bIntegratedMMEnabled = FALSE;
4991               }
4992            }
4993         }
4994 #endif
4995
4996         ivideo->bios_abase = NULL;
4997         ivideo->bios_vbase = NULL;
4998         if(ivideo->sisfb_userom) {
4999             ivideo->sishw_ext.pjVirtualRomBase = sis_find_rom(pdev);
5000 #if defined(__i386__) || defined(__x86_64__)
5001             ivideo->bios_vbase = ivideo->sishw_ext.pjVirtualRomBase;    /* mapped */
5002 #else
5003             ivideo->bios_abase = ivideo->sishw_ext.pjVirtualRomBase;    /* allocated */
5004 #endif
5005             if(ivideo->sishw_ext.pjVirtualRomBase) {
5006                 printk(KERN_INFO "sisfb: Video ROM found and %s to 0x%p\n",
5007                         ivideo->bios_vbase ? "mapped" : "copied",
5008                         ivideo->sishw_ext.pjVirtualRomBase);
5009                 ivideo->sishw_ext.UseROM = TRUE;
5010             } else {
5011                 ivideo->sishw_ext.UseROM = FALSE;
5012                 printk(KERN_INFO "sisfb: Video ROM not found\n");
5013             }
5014         } else {
5015             ivideo->sishw_ext.pjVirtualRomBase = NULL;
5016             ivideo->sishw_ext.UseROM = FALSE;
5017             printk(KERN_INFO "sisfb: Video ROM usage disabled\n");
5018         }
5019
5020         /* Find systems for special custom timing */
5021         if(ivideo->SiS_Pr.SiS_CustomT == CUT_NONE) {
5022            int j;
5023            unsigned char *biosver = NULL;
5024            unsigned char *biosdate = NULL;
5025            BOOLEAN footprint;
5026            u32 chksum = 0;
5027
5028            if(ivideo->sishw_ext.UseROM) {
5029               biosver = ivideo->sishw_ext.pjVirtualRomBase + 0x06;
5030               biosdate = ivideo->sishw_ext.pjVirtualRomBase + 0x2c;
5031               for(i=0; i<32768; i++) chksum += ivideo->sishw_ext.pjVirtualRomBase[i];
5032            }
5033
5034            i=0;
5035            do {
5036               if( (mycustomttable[i].chipID == ivideo->chip) &&
5037                   ((!strlen(mycustomttable[i].biosversion)) ||
5038                    (ivideo->sishw_ext.UseROM &&
5039                    (!strncmp(mycustomttable[i].biosversion, biosver, strlen(mycustomttable[i].biosversion))))) &&
5040                   ((!strlen(mycustomttable[i].biosdate)) ||
5041                    (ivideo->sishw_ext.UseROM &&
5042                    (!strncmp(mycustomttable[i].biosdate, biosdate, strlen(mycustomttable[i].biosdate))))) &&
5043                   ((!mycustomttable[i].bioschksum) ||
5044                    (ivideo->sishw_ext.UseROM &&
5045                    (mycustomttable[i].bioschksum == chksum)))   &&
5046                   (mycustomttable[i].pcisubsysvendor == ivideo->subsysvendor) &&
5047                   (mycustomttable[i].pcisubsyscard == ivideo->subsysdevice) ) {
5048                  footprint = TRUE;
5049                  for(j = 0; j < 5; j++) {
5050                     if(mycustomttable[i].biosFootprintAddr[j]) {
5051                        if(ivideo->sishw_ext.UseROM) {
5052                           if(ivideo->sishw_ext.pjVirtualRomBase[mycustomttable[i].biosFootprintAddr[j]] !=
5053                                 mycustomttable[i].biosFootprintData[j]) {
5054                              footprint = FALSE;
5055                           }
5056                        } else footprint = FALSE;
5057                     }
5058                  }
5059                  if(footprint) {
5060                     ivideo->SiS_Pr.SiS_CustomT = mycustomttable[i].SpecialID;
5061                     printk(KERN_DEBUG "sisfb: Identified [%s %s], special timing applies\n",
5062                         mycustomttable[i].vendorName,
5063                         mycustomttable[i].cardName);
5064                     printk(KERN_DEBUG "sisfb: [specialtiming parameter name: %s]\n",
5065                         mycustomttable[i].optionName);
5066                     break;
5067                  }
5068               }
5069               i++;
5070            } while(mycustomttable[i].chipID);
5071         }
5072
5073 #ifdef CONFIG_FB_SIS_300
5074         if(ivideo->sisvga_engine == SIS_300_VGA) {
5075                 if( (!sisvga_enabled)
5076 #if !defined(__i386__) && !defined(__x86_64__)
5077                                       || (sisfb_resetcard)
5078 #endif
5079                                                            ) {
5080                         if(ivideo->chip == SIS_300) {
5081                                 sisfb_post_sis300(pdev);
5082                         }
5083                 }
5084         }
5085 #endif
5086
5087 #ifdef CONFIG_FB_SIS_315
5088         if(ivideo->sisvga_engine == SIS_315_VGA) {
5089                 if( (!sisvga_enabled)
5090 #if !defined(__i386__) && !defined(__x86_64__)
5091                                      || (sisfb_resetcard)
5092 #endif
5093                                                           ) {
5094                         if((ivideo->chip == SIS_315H)   ||
5095                            (ivideo->chip == SIS_315)    ||
5096                            (ivideo->chip == SIS_315PRO) ||
5097                            (ivideo->chip == SIS_330)) {
5098                                 sisfb_post_sis315330(pdev);
5099                         }
5100                 }
5101         }
5102 #endif
5103
5104         if(sisfb_get_dram_size(ivideo)) {
5105                 printk(KERN_INFO "sisfb: Fatal error: Unable to determine RAM size.\n");
5106                 if(ivideo->bios_abase) vfree(ivideo->bios_abase);
5107                 pci_set_drvdata(pdev, NULL);
5108                 kfree(sis_fb_info);
5109                 return -ENODEV;
5110         }
5111
5112         if((ivideo->sisfb_mode_idx < 0) ||
5113            ((sisbios_mode[ivideo->sisfb_mode_idx].mode_no[ivideo->mni]) != 0xFF)) {
5114                 /* Enable PCI_LINEAR_ADDRESSING and MMIO_ENABLE  */
5115                 orSISIDXREG(SISSR, IND_SIS_PCI_ADDRESS_SET, (SIS_PCI_ADDR_ENABLE | SIS_MEM_MAP_IO_ENABLE));
5116                 /* Enable 2D accelerator engine */
5117                 orSISIDXREG(SISSR, IND_SIS_MODULE_ENABLE, SIS_ENABLE_2D);
5118         }
5119
5120         if(sisfb_pdc != 0xff) {
5121            if(ivideo->sisvga_engine == SIS_300_VGA) sisfb_pdc &= 0x3c;
5122            else                                     sisfb_pdc &= 0x1f;
5123            ivideo->SiS_Pr.PDC = sisfb_pdc;
5124         }
5125 #ifdef CONFIG_FB_SIS_315
5126         if(ivideo->sisvga_engine == SIS_315_VGA) {
5127            if(sisfb_pdca != 0xff) ivideo->SiS_Pr.PDCA = sisfb_pdca & 0x1f;
5128         }
5129 #endif
5130
5131         if(!request_mem_region(ivideo->video_base, ivideo->video_size, "sisfb FB")) {
5132                 printk(KERN_ERR "sisfb: Fatal error: Unable to reserve frame buffer memory\n");
5133                 printk(KERN_ERR "sisfb: Is there another framebuffer driver active?\n");
5134                 if(ivideo->bios_abase) vfree(ivideo->bios_abase);
5135                 if(ivideo->bios_vbase) iounmap(ivideo->bios_vbase);
5136                 pci_set_drvdata(pdev, NULL);
5137                 kfree(sis_fb_info);
5138                 return -ENODEV;
5139         }
5140
5141         if(!request_mem_region(ivideo->mmio_base, ivideo->mmio_size, "sisfb MMIO")) {
5142                 printk(KERN_ERR "sisfb: Fatal error: Unable to reserve MMIO region\n");
5143                 release_mem_region(ivideo->video_base, ivideo->video_size);
5144                 if(ivideo->bios_abase) vfree(ivideo->bios_abase);
5145                 if(ivideo->bios_vbase) iounmap(ivideo->bios_vbase);
5146                 pci_set_drvdata(pdev, NULL);
5147                 kfree(sis_fb_info);
5148                 return -ENODEV;
5149         }
5150
5151         ivideo->video_vbase = ioremap(ivideo->video_base, ivideo->video_size);
5152         ivideo->sishw_ext.pjVideoMemoryAddress = ivideo->video_vbase;
5153         if(!ivideo->video_vbase) {
5154                 printk(KERN_ERR "sisfb: Fatal error: Unable to map frame buffer memory\n");
5155                 release_mem_region(ivideo->video_base, ivideo->video_size);
5156                 release_mem_region(ivideo->mmio_base, ivideo->mmio_size);
5157                 if(ivideo->bios_abase) vfree(ivideo->bios_abase);
5158                 if(ivideo->bios_vbase) iounmap(ivideo->bios_vbase);
5159                 pci_set_drvdata(pdev, NULL);
5160                 kfree(sis_fb_info);
5161                 return -ENODEV;
5162         }
5163
5164         ivideo->mmio_vbase = ioremap(ivideo->mmio_base, ivideo->mmio_size);
5165         if(!ivideo->mmio_vbase) {
5166                 printk(KERN_ERR "sisfb: Fatal error: Unable to map MMIO region\n");
5167                 iounmap(ivideo->video_vbase);
5168                 release_mem_region(ivideo->video_base, ivideo->video_size);
5169                 release_mem_region(ivideo->mmio_base, ivideo->mmio_size);
5170                 if(ivideo->bios_abase) vfree(ivideo->bios_abase);
5171                 if(ivideo->bios_vbase) iounmap(ivideo->bios_vbase);
5172                 pci_set_drvdata(pdev, NULL);
5173                 kfree(sis_fb_info);
5174                 return -ENODEV;
5175         }
5176
5177         printk(KERN_INFO "sisfb: Framebuffer at 0x%lx, mapped to 0x%p, size %ldk\n",
5178                 ivideo->video_base, ivideo->video_vbase, ivideo->video_size / 1024);
5179
5180         printk(KERN_INFO "sisfb: MMIO at 0x%lx, mapped to 0x%p, size %ldk\n",
5181                 ivideo->mmio_base, ivideo->mmio_vbase, ivideo->mmio_size / 1024);
5182
5183         if((ivideo->havenoheap = sisfb_heap_init(ivideo))) {
5184                 printk(KERN_WARNING "sisfb: Failed to initialize offscreen memory heap\n");
5185         }
5186
5187         /* Used for clearing the screen only, therefore respect our mem limit */
5188         ivideo->sishw_ext.ulVideoMemorySize = ivideo->sisfb_mem;
5189
5190         ivideo->mtrr = 0;
5191
5192         ivideo->vbflags = 0;
5193         ivideo->lcddefmodeidx = DEFAULT_LCDMODE;
5194         ivideo->tvdefmodeidx  = DEFAULT_TVMODE;
5195         ivideo->defmodeidx    = DEFAULT_MODE;
5196
5197         ivideo->newrom = SiSDetermineROMLayout661(&ivideo->SiS_Pr, &ivideo->sishw_ext);
5198
5199         if((ivideo->sisfb_mode_idx < 0) ||
5200            ((sisbios_mode[ivideo->sisfb_mode_idx].mode_no[ivideo->mni]) != 0xFF)) {
5201
5202                 sisfb_sense_crt1(ivideo);
5203
5204                 sisfb_get_VB_type(ivideo);
5205
5206                 if(ivideo->vbflags & VB_VIDEOBRIDGE) {
5207                         sisfb_detect_VB_connect(ivideo);
5208                 }
5209
5210                 ivideo->currentvbflags = ivideo->vbflags & (VB_VIDEOBRIDGE | TV_STANDARD);
5211
5212                 if(ivideo->vbflags & VB_VIDEOBRIDGE) {
5213                    if(ivideo->sisfb_crt2type != -1) {
5214                       if((ivideo->sisfb_crt2type == CRT2_LCD) && (ivideo->vbflags & CRT2_LCD)) {
5215                          ivideo->currentvbflags |= CRT2_LCD;
5216                       } else if(ivideo->sisfb_crt2type != CRT2_LCD) {
5217                          ivideo->currentvbflags |= ivideo->sisfb_crt2type;
5218                       }
5219                    } else {
5220                       /* Chrontel 700x TV detection often unreliable, therefore use a
5221                        * different default order on such machines
5222                        */
5223                       if((ivideo->sisvga_engine == SIS_300_VGA) && (ivideo->vbflags & VB_CHRONTEL)) {
5224                          if(ivideo->vbflags & CRT2_LCD)      ivideo->currentvbflags |= CRT2_LCD;
5225                          else if(ivideo->vbflags & CRT2_TV)  ivideo->currentvbflags |= CRT2_TV;
5226                          else if(ivideo->vbflags & CRT2_VGA) ivideo->currentvbflags |= CRT2_VGA;
5227                       } else {
5228                          if(ivideo->vbflags & CRT2_TV)       ivideo->currentvbflags |= CRT2_TV;
5229                          else if(ivideo->vbflags & CRT2_LCD) ivideo->currentvbflags |= CRT2_LCD;
5230                          else if(ivideo->vbflags & CRT2_VGA) ivideo->currentvbflags |= CRT2_VGA;
5231                       }
5232                    }
5233                 }
5234
5235                 if(ivideo->vbflags & CRT2_LCD) {
5236                    inSISIDXREG(SISCR, 0x36, reg);
5237                    reg &= 0x0f;
5238                    if(ivideo->sisvga_engine == SIS_300_VGA) {
5239                       ivideo->sishw_ext.ulCRT2LCDType = sis300paneltype[reg];
5240                    } else if(ivideo->chip >= SIS_661) {
5241                       ivideo->sishw_ext.ulCRT2LCDType = sis661paneltype[reg];
5242                    } else {
5243                       ivideo->sishw_ext.ulCRT2LCDType = sis310paneltype[reg];
5244                       if((ivideo->chip == SIS_550) && (sisfb_fstn)) {
5245                          if((ivideo->sishw_ext.ulCRT2LCDType != LCD_640x480_2) &&
5246                             (ivideo->sishw_ext.ulCRT2LCDType != LCD_640x480_3)) {
5247                             ivideo->sishw_ext.ulCRT2LCDType = LCD_320x480;
5248                          }
5249                       }
5250                    }
5251                    if(ivideo->sishw_ext.ulCRT2LCDType == LCD_UNKNOWN) {
5252                       ivideo->sishw_ext.ulCRT2LCDType = LCD_1024x768;
5253                       printk(KERN_DEBUG "sisfb: Illegal panel ID (%02x), assuming 1024x768\n", reg);
5254                    }
5255                    for(i = 0; i < SIS_LCD_NUMBER; i++) {
5256                       if(ivideo->sishw_ext.ulCRT2LCDType == sis_lcd_data[i].lcdtype) {
5257                          ivideo->lcdxres = sis_lcd_data[i].xres;
5258                          ivideo->lcdyres = sis_lcd_data[i].yres;
5259                          ivideo->lcddefmodeidx = sis_lcd_data[i].default_mode_idx;
5260                          break;
5261                       }
5262                    }
5263                    if(ivideo->SiS_Pr.SiS_CustomT == CUT_BARCO1366) {
5264                         ivideo->lcdxres = 1360; ivideo->lcdyres = 1024; ivideo->lcddefmodeidx = 99;
5265                    } else if(ivideo->SiS_Pr.SiS_CustomT == CUT_PANEL848) {
5266                         ivideo->lcdxres =  848; ivideo->lcdyres =  480; ivideo->lcddefmodeidx = 47;
5267                    }
5268                    printk(KERN_DEBUG "sisfb: Detected %dx%d flat panel\n",
5269                                 ivideo->lcdxres, ivideo->lcdyres);
5270                 }
5271
5272 #ifdef CONFIG_FB_SIS_300
5273                 /* Save the current PanelDelayCompensation if the LCD is currently used */
5274                 if(ivideo->sisvga_engine == SIS_300_VGA) {
5275                    if(ivideo->vbflags & (VB_LVDS | VB_30xBDH)) {
5276                        int tmp;
5277                        inSISIDXREG(SISCR,0x30,tmp);
5278                        if(tmp & 0x20) {
5279                           /* Currently on LCD? If yes, read current pdc */
5280                           inSISIDXREG(SISPART1,0x13,ivideo->detectedpdc);
5281                           ivideo->detectedpdc &= 0x3c;
5282                           if(ivideo->SiS_Pr.PDC == -1) {
5283                              /* Let option override detection */
5284                              ivideo->SiS_Pr.PDC = ivideo->detectedpdc;
5285                           }
5286                           printk(KERN_INFO "sisfb: Detected LCD PDC 0x%02x\n",
5287                                  ivideo->detectedpdc);
5288                        }
5289                        if((ivideo->SiS_Pr.PDC != -1) && (ivideo->SiS_Pr.PDC != ivideo->detectedpdc)) {
5290                           printk(KERN_INFO "sisfb: Using LCD PDC 0x%02x\n",
5291                                  ivideo->SiS_Pr.PDC);
5292                        }
5293                    }
5294                 }
5295 #endif
5296
5297 #ifdef CONFIG_FB_SIS_315
5298                 if(ivideo->sisvga_engine == SIS_315_VGA) {
5299
5300                    /* Try to find about LCDA */
5301                    if(ivideo->vbflags & (VB_301C | VB_302B | VB_301LV | VB_302LV | VB_302ELV)) {
5302                       int tmp;
5303                       inSISIDXREG(SISPART1,0x13,tmp);
5304                       if(tmp & 0x04) {
5305                          ivideo->SiS_Pr.SiS_UseLCDA = TRUE;
5306                          ivideo->detectedlcda = 0x03;
5307                       }
5308                    }
5309
5310                    /* Save PDC */
5311                    if(ivideo->vbflags & (VB_301LV | VB_302LV | VB_302ELV)) {
5312                       int tmp;
5313                       inSISIDXREG(SISCR,0x30,tmp);
5314                       if((tmp & 0x20) || (ivideo->detectedlcda != 0xff)) {
5315                          /* Currently on LCD? If yes, read current pdc */
5316                          u8 pdc;
5317                          inSISIDXREG(SISPART1,0x2D,pdc);
5318                          ivideo->detectedpdc  = (pdc & 0x0f) << 1;
5319                          ivideo->detectedpdca = (pdc & 0xf0) >> 3;
5320                          inSISIDXREG(SISPART1,0x35,pdc);
5321                          ivideo->detectedpdc |= ((pdc >> 7) & 0x01);
5322                          inSISIDXREG(SISPART1,0x20,pdc);
5323                          ivideo->detectedpdca |= ((pdc >> 6) & 0x01);
5324                          if(ivideo->newrom) {
5325                             /* New ROM invalidates other PDC resp. */
5326                             if(ivideo->detectedlcda != 0xff) {
5327                                ivideo->detectedpdc = 0xff;
5328                             } else {
5329                                ivideo->detectedpdca = 0xff;
5330                             }
5331                          }
5332                          if(ivideo->SiS_Pr.PDC == -1) {
5333                             if(ivideo->detectedpdc != 0xff) {
5334                                ivideo->SiS_Pr.PDC = ivideo->detectedpdc;
5335                             }
5336                          }
5337                          if(ivideo->SiS_Pr.PDCA == -1) {
5338                             if(ivideo->detectedpdca != 0xff) {
5339                                ivideo->SiS_Pr.PDCA = ivideo->detectedpdca;
5340                             }
5341                          }
5342                          if(ivideo->detectedpdc != 0xff) {
5343                             printk(KERN_INFO
5344                                  "sisfb: Detected LCD PDC 0x%02x (for LCD=CRT2)\n",
5345                                   ivideo->detectedpdc);
5346                          }
5347                          if(ivideo->detectedpdca != 0xff) {
5348                             printk(KERN_INFO
5349                                  "sisfb: Detected LCD PDC1 0x%02x (for LCD=CRT1)\n",
5350                                   ivideo->detectedpdca);
5351                          }
5352                       }
5353
5354                       /* Save EMI */
5355                       if(ivideo->vbflags & (VB_302LV | VB_302ELV)) {
5356                          inSISIDXREG(SISPART4,0x30,ivideo->SiS_Pr.EMI_30);
5357                          inSISIDXREG(SISPART4,0x31,ivideo->SiS_Pr.EMI_31);
5358                          inSISIDXREG(SISPART4,0x32,ivideo->SiS_Pr.EMI_32);
5359                          inSISIDXREG(SISPART4,0x33,ivideo->SiS_Pr.EMI_33);
5360                          ivideo->SiS_Pr.HaveEMI = TRUE;
5361                          if((tmp & 0x20) || (ivideo->detectedlcda != 0xff)) {
5362                                 ivideo->SiS_Pr.HaveEMILCD = TRUE;
5363                          }
5364                       }
5365                    }
5366
5367                    /* Let user override detected PDCs (all bridges) */
5368                    if(ivideo->vbflags & (VB_301B | VB_301C | VB_301LV | VB_302LV | VB_302ELV)) {
5369                       if((ivideo->SiS_Pr.PDC != -1) && (ivideo->SiS_Pr.PDC != ivideo->detectedpdc)) {
5370                          printk(KERN_INFO "sisfb: Using LCD PDC 0x%02x (for LCD=CRT2)\n",
5371                                  ivideo->SiS_Pr.PDC);
5372                       }
5373                       if((ivideo->SiS_Pr.PDCA != -1) && (ivideo->SiS_Pr.PDCA != ivideo->detectedpdca)) {
5374                          printk(KERN_INFO "sisfb: Using LCD PDC1 0x%02x (for LCD=CRT1)\n",
5375                                  ivideo->SiS_Pr.PDCA);
5376                       }
5377                    }
5378
5379                 }
5380 #endif
5381
5382                 if(!ivideo->sisfb_crt1off) {
5383                         sisfb_handle_ddc(ivideo, &ivideo->sisfb_thismonitor, 0);
5384                 } else {
5385                         if((ivideo->vbflags & (VB_301|VB_301B|VB_301C|VB_302B)) &&
5386                            (ivideo->vbflags & (CRT2_VGA | CRT2_LCD))) {
5387                                 sisfb_handle_ddc(ivideo, &ivideo->sisfb_thismonitor, 1);
5388                         }
5389                 }
5390
5391                 if(ivideo->sisfb_mode_idx >= 0) {
5392                         int bu = ivideo->sisfb_mode_idx;
5393                         ivideo->sisfb_mode_idx = sisfb_validate_mode(ivideo,
5394                                         ivideo->sisfb_mode_idx, ivideo->currentvbflags);
5395                         if(bu != ivideo->sisfb_mode_idx) {
5396                                 printk(KERN_ERR "Mode %dx%dx%d failed validation\n",
5397                                         sisbios_mode[bu].xres,
5398                                         sisbios_mode[bu].yres,
5399                                         sisbios_mode[bu].bpp);
5400                         }
5401                 }
5402
5403                 if(ivideo->sisfb_mode_idx < 0) {
5404                         switch(ivideo->currentvbflags & VB_DISPTYPE_DISP2) {
5405                            case CRT2_LCD:
5406                                 ivideo->sisfb_mode_idx = ivideo->lcddefmodeidx;
5407                                 break;
5408                            case CRT2_TV:
5409                                 ivideo->sisfb_mode_idx = ivideo->tvdefmodeidx;
5410                                 break;
5411                            default:
5412                                 ivideo->sisfb_mode_idx = ivideo->defmodeidx;
5413                                 break;
5414                         }
5415                 }
5416
5417                 ivideo->mode_no = sisbios_mode[ivideo->sisfb_mode_idx].mode_no[ivideo->mni];
5418
5419                 if(ivideo->refresh_rate != 0) {
5420                         sisfb_search_refresh_rate(ivideo, ivideo->refresh_rate, ivideo->sisfb_mode_idx);
5421                 }
5422
5423                 if(ivideo->rate_idx == 0) {
5424                         ivideo->rate_idx = sisbios_mode[ivideo->sisfb_mode_idx].rate_idx;
5425                         ivideo->refresh_rate = 60;
5426                 }
5427
5428                 if(ivideo->sisfb_thismonitor.datavalid) {
5429                         if(!sisfb_verify_rate(ivideo, &ivideo->sisfb_thismonitor, ivideo->sisfb_mode_idx,
5430                                               ivideo->rate_idx, ivideo->refresh_rate)) {
5431                                 printk(KERN_INFO "sisfb: WARNING: Refresh rate exceeds monitor specs!\n");
5432                         }
5433                 }
5434
5435                 ivideo->video_bpp = sisbios_mode[ivideo->sisfb_mode_idx].bpp;
5436                 ivideo->video_width = sisbios_mode[ivideo->sisfb_mode_idx].xres;
5437                 ivideo->video_height = sisbios_mode[ivideo->sisfb_mode_idx].yres;
5438
5439                 sisfb_set_vparms(ivideo);
5440
5441 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
5442
5443                 /* ---------------- For 2.4: Now switch the mode ------------------ */
5444
5445                 printk(KERN_INFO "sisfb: Mode is %dx%dx%d (%dHz)\n",
5446                         ivideo->video_width, ivideo->video_height, ivideo->video_bpp,
5447                         ivideo->refresh_rate);
5448
5449                 sisfb_pre_setmode(ivideo);
5450
5451                 if(SiSSetMode(&ivideo->SiS_Pr, &ivideo->sishw_ext, ivideo->mode_no) == 0) {
5452                         printk(KERN_ERR "sisfb: Fatal error: Setting mode[0x%x] failed\n",
5453                                                                         ivideo->mode_no);
5454                         iounmap(ivideo->video_vbase);
5455                         iounmap(ivideo->mmio_vbase);
5456                         release_mem_region(ivideo->video_base, ivideo->video_size);
5457                         release_mem_region(ivideo->mmio_base, ivideo->mmio_size);
5458                         if(ivideo->bios_abase) vfree(ivideo->bios_abase);
5459                         if(ivideo->bios_vbase) iounmap(ivideo->bios_vbase);
5460                         pci_set_drvdata(pdev, NULL);
5461                         kfree(sis_fb_info);
5462                         return -EINVAL;
5463                 }
5464
5465                 outSISIDXREG(SISSR, IND_SIS_PASSWORD, SIS_PASSWORD);
5466
5467                 sisfb_post_setmode(ivideo);
5468
5469                 /* Maximize regardless of sisfb_max at startup */
5470                 ivideo->default_var.yres_virtual = 32767;
5471
5472                 /* Force reset of x virtual in crtc_to_var */
5473                 ivideo->default_var.xres_virtual = 0;
5474
5475                 sisfb_crtc_to_var(ivideo, &ivideo->default_var);
5476
5477                 sisfb_calc_pitch(ivideo, &ivideo->default_var);
5478                 sisfb_set_pitch(ivideo);
5479
5480                 ivideo->accel = 0;
5481                 if(ivideo->sisfb_accel) {
5482                    ivideo->accel = -1;
5483                    ivideo->default_var.accel_flags |= FB_ACCELF_TEXT;
5484                 }
5485                 sisfb_initaccel(ivideo);
5486
5487                 sis_fb_info->node  = -1;
5488                 sis_fb_info->flags = FBINFO_FLAG_DEFAULT;
5489                 sis_fb_info->fbops = &sisfb_ops;
5490                 sis_fb_info->disp  = &ivideo->sis_disp;
5491                 sis_fb_info->blank = &sisfb_blank;
5492                 sis_fb_info->switch_con = &sisfb_switch;
5493                 sis_fb_info->updatevar  = &sisfb_update_var;
5494                 sis_fb_info->changevar  = NULL;
5495                 strcpy(sis_fb_info->fontname, sisfb_fontname);
5496
5497                 sisfb_set_disp(-1, &ivideo->default_var, sis_fb_info);
5498
5499 #else           /* --------- For 2.6: Setup a somewhat sane default var ------------ */
5500
5501                 printk(KERN_INFO "sisfb: Default mode is %dx%dx%d (%dHz)\n",
5502                         ivideo->video_width, ivideo->video_height, ivideo->video_bpp,
5503                         ivideo->refresh_rate);
5504
5505                 ivideo->default_var.xres = ivideo->default_var.xres_virtual = ivideo->video_width;
5506                 ivideo->default_var.yres = ivideo->default_var.yres_virtual = ivideo->video_height;
5507                 ivideo->default_var.bits_per_pixel = ivideo->video_bpp;
5508
5509                 sisfb_bpp_to_var(ivideo, &ivideo->default_var);
5510
5511                 ivideo->default_var.pixclock = (u32) (1000000000 /
5512                                 sisfb_mode_rate_to_dclock(&ivideo->SiS_Pr, &ivideo->sishw_ext,
5513                                                 ivideo->mode_no, ivideo->rate_idx));
5514
5515                 if(sisfb_mode_rate_to_ddata(&ivideo->SiS_Pr, &ivideo->sishw_ext,
5516                                 ivideo->mode_no, ivideo->rate_idx, &ivideo->default_var)) {
5517                    if((ivideo->default_var.vmode & FB_VMODE_MASK) == FB_VMODE_DOUBLE) {
5518                       ivideo->default_var.pixclock <<= 1;
5519                    }
5520                 }
5521
5522                 if(ivideo->sisfb_ypan) {
5523                    /* Maximize regardless of sisfb_max at startup */
5524                    ivideo->default_var.yres_virtual = sisfb_calc_maxyres(ivideo, &ivideo->default_var);
5525                    if(ivideo->default_var.yres_virtual < ivideo->default_var.yres) {
5526                       ivideo->default_var.yres_virtual = ivideo->default_var.yres;
5527                    }
5528                 }
5529
5530                 sisfb_calc_pitch(ivideo, &ivideo->default_var);
5531
5532                 ivideo->accel = 0;
5533                 if(ivideo->sisfb_accel) {
5534                    ivideo->accel = -1;
5535 #ifdef STUPID_ACCELF_TEXT_SHIT
5536                    ivideo->default_var.accel_flags |= FB_ACCELF_TEXT;
5537 #endif
5538                 }
5539                 sisfb_initaccel(ivideo);
5540
5541 #if defined(FBINFO_HWACCEL_DISABLED) && defined(FBINFO_HWACCEL_XPAN)
5542                 sis_fb_info->flags = FBINFO_DEFAULT             |
5543                                      FBINFO_HWACCEL_YPAN        |
5544                                      FBINFO_HWACCEL_XPAN        |
5545                                      FBINFO_HWACCEL_COPYAREA    |
5546                                      FBINFO_HWACCEL_FILLRECT    |
5547                                      ((ivideo->accel) ? 0 : FBINFO_HWACCEL_DISABLED);
5548 #else
5549                 sis_fb_info->flags = FBINFO_FLAG_DEFAULT;
5550 #endif
5551                 sis_fb_info->var = ivideo->default_var;
5552                 sis_fb_info->fix = ivideo->sisfb_fix;
5553                 sis_fb_info->screen_base = ivideo->video_vbase;
5554                 sis_fb_info->fbops = &sisfb_ops;
5555
5556                 sisfb_get_fix(&sis_fb_info->fix, -1, sis_fb_info);
5557                 sis_fb_info->pseudo_palette = ivideo->pseudo_palette;
5558
5559                 fb_alloc_cmap(&sis_fb_info->cmap, 256 , 0);
5560 #endif          /* 2.6 */
5561
5562                 printk(KERN_DEBUG "sisfb: Initial vbflags 0x%lx\n", (unsigned long)ivideo->vbflags);
5563
5564 #ifdef CONFIG_MTRR
5565                 ivideo->mtrr = mtrr_add(ivideo->video_base, ivideo->video_size,
5566                                         MTRR_TYPE_WRCOMB, 1);
5567                 if(!ivideo->mtrr) {
5568                         printk(KERN_DEBUG "sisfb: Failed to add MTRRs\n");
5569                 }
5570 #endif
5571
5572 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
5573                 vc_resize_con(1, 1, 0);
5574 #endif
5575
5576                 if(register_framebuffer(sis_fb_info) < 0) {
5577                         printk(KERN_ERR "sisfb: Fatal error: Failed to register framebuffer\n");
5578                         iounmap(ivideo->video_vbase);
5579                         iounmap(ivideo->mmio_vbase);
5580                         release_mem_region(ivideo->video_base, ivideo->video_size);
5581                         release_mem_region(ivideo->mmio_base, ivideo->mmio_size);
5582                         if(ivideo->bios_abase) vfree(ivideo->bios_abase);
5583                         if(ivideo->bios_vbase) iounmap(ivideo->bios_vbase);
5584                         pci_set_drvdata(pdev, NULL);
5585                         kfree(sis_fb_info);
5586                         return -EINVAL;
5587                 }
5588
5589                 ivideo->registered = 1;
5590
5591                 /* Enlist us */
5592                 ivideo->next = card_list;
5593                 card_list = ivideo;
5594
5595 #ifdef SIS_CONFIG_COMPAT
5596                 {
5597                 int ret;
5598                 /* Our ioctls are all "32/64bit compatible" */
5599                 if(register_ioctl32_conversion(FBIOGET_VBLANK, NULL)) {
5600                    printk(KERN_ERR "sisfb: Error registering FBIOGET_VBLANK ioctl32 translation\n");
5601                 } else {
5602                    ivideo->ioctl32vblankregistered = 1;
5603                 }
5604                 ret =  register_ioctl32_conversion(FBIO_ALLOC,             NULL);
5605                 ret |= register_ioctl32_conversion(FBIO_FREE,              NULL);
5606                 ret |= register_ioctl32_conversion(SISFB_GET_INFO_SIZE,    NULL);
5607                 ret |= register_ioctl32_conversion(SISFB_GET_INFO,         NULL);
5608                 ret |= register_ioctl32_conversion(SISFB_GET_TVPOSOFFSET,  NULL);
5609                 ret |= register_ioctl32_conversion(SISFB_SET_TVPOSOFFSET,  NULL);
5610                 ret |= register_ioctl32_conversion(SISFB_SET_LOCK,         NULL);
5611                 ret |= register_ioctl32_conversion(SISFB_GET_VBRSTATUS,    NULL);
5612                 ret |= register_ioctl32_conversion(SISFB_GET_AUTOMAXIMIZE, NULL);
5613                 ret |= register_ioctl32_conversion(SISFB_SET_AUTOMAXIMIZE, NULL);
5614                 if(ret) printk(KERN_ERR "sisfb: Error registering ioctl32 translations\n");
5615                 else    ivideo->ioctl32registered = 1;
5616                 }
5617 #endif
5618
5619                 printk(KERN_INFO "sisfb: 2D acceleration is %s, y-panning %s\n",
5620                      ivideo->sisfb_accel ? "enabled" : "disabled",
5621                      ivideo->sisfb_ypan  ?
5622                         (ivideo->sisfb_max ? "enabled (auto-max)" : "enabled (no auto-max)") : "disabled");
5623
5624
5625                 printk(KERN_INFO "fb%d: %s frame buffer device, Version %d.%d.%d\n",
5626 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
5627                         GET_FB_IDX(sis_fb_info->node),
5628 #else
5629                         sis_fb_info->node,
5630 #endif
5631                         ivideo->myid, VER_MAJOR, VER_MINOR, VER_LEVEL);
5632
5633                 printk(KERN_INFO "sisfb: (C) 2001-2004 Thomas Winischhofer.\n");
5634
5635         }       /* if mode = "none" */
5636
5637         return 0;
5638 }
5639
5640 /*****************************************************/
5641 /*                PCI DEVICE HANDLING                */
5642 /*****************************************************/
5643
5644 static void __devexit sisfb_remove(struct pci_dev *pdev)
5645 {
5646         struct sis_video_info *ivideo = pci_get_drvdata(pdev);
5647         struct fb_info        *sis_fb_info = ivideo->memyselfandi;
5648         int                   registered = ivideo->registered;
5649
5650 #ifdef SIS_CONFIG_COMPAT
5651         if(ivideo->ioctl32vblankregistered) {
5652                 if(unregister_ioctl32_conversion(FBIOGET_VBLANK)) {
5653                         printk(KERN_ERR "sisfb: Error unregistering FBIOGET_VBLANK ioctl32 translation\n");
5654                 }
5655         }
5656         if(ivideo->ioctl32registered) {
5657                 int ret;
5658                 ret =  unregister_ioctl32_conversion(FBIO_ALLOC);
5659                 ret |= unregister_ioctl32_conversion(FBIO_FREE);
5660                 ret |= unregister_ioctl32_conversion(SISFB_GET_INFO_SIZE);
5661                 ret |= unregister_ioctl32_conversion(SISFB_GET_INFO);
5662                 ret |= unregister_ioctl32_conversion(SISFB_GET_TVPOSOFFSET);
5663                 ret |= unregister_ioctl32_conversion(SISFB_SET_TVPOSOFFSET);
5664                 ret |= unregister_ioctl32_conversion(SISFB_SET_LOCK);
5665                 ret |= unregister_ioctl32_conversion(SISFB_GET_VBRSTATUS);
5666                 ret |= unregister_ioctl32_conversion(SISFB_GET_AUTOMAXIMIZE);
5667                 ret |= unregister_ioctl32_conversion(SISFB_SET_AUTOMAXIMIZE);
5668                 if(ret) printk(KERN_ERR "sisfb: Error unregistering ioctl32 translations\n");
5669         }
5670 #endif
5671
5672         /* Unmap */
5673         iounmap(ivideo->video_vbase);
5674         iounmap(ivideo->mmio_vbase);
5675         if(ivideo->bios_vbase) iounmap(ivideo->bios_vbase);
5676         if(ivideo->bios_abase)    vfree(ivideo->bios_abase);
5677
5678         /* Release mem regions */
5679         release_mem_region(ivideo->video_base, ivideo->video_size);
5680         release_mem_region(ivideo->mmio_base, ivideo->mmio_size);
5681
5682 #ifdef CONFIG_MTRR
5683         /* Release MTRR region */
5684         if(ivideo->mtrr) {
5685                 mtrr_del(ivideo->mtrr, ivideo->video_base, ivideo->video_size);
5686         }
5687 #endif
5688
5689         /* Unregister the framebuffer */
5690         if(ivideo->registered) {
5691                 unregister_framebuffer(sis_fb_info);
5692 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,3))
5693                 framebuffer_release(sis_fb_info);
5694 #else
5695                 kfree(sis_fb_info);
5696 #endif
5697         }
5698
5699         pci_set_drvdata(pdev, NULL);
5700
5701         /* TODO: Restore the initial mode
5702          * This sounds easy but is as good as impossible
5703          * on many machines with SiS chip and video bridge
5704          * since text modes are always set up differently
5705          * from machine to machine. Depends on the type
5706          * of integration between chipset and bridge.
5707          */
5708         if(registered) {
5709            printk(KERN_INFO "sisfb: Restoring of text mode not supported yet\n");
5710         }
5711 };
5712
5713 static struct pci_driver sisfb_driver = {
5714         .name           = "sisfb",
5715         .id_table       = sisfb_pci_table,
5716         .probe          = sisfb_probe,
5717         .remove         = __devexit_p(sisfb_remove)
5718 };
5719
5720 int __init sisfb_init(void)
5721 {
5722 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,8)
5723 #ifndef MODULE
5724         char *option = NULL;
5725
5726         if (fb_get_options("sisfb", &option))
5727                 return -ENODEV;
5728         sisfb_setup(option);
5729 #endif
5730 #endif
5731         return(pci_module_init(&sisfb_driver));
5732 }
5733
5734 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,8)
5735 #ifndef MODULE
5736 module_init(sisfb_init);
5737 #endif
5738 #endif
5739
5740 /*****************************************************/
5741 /*                      MODULE                       */
5742 /*****************************************************/
5743
5744 #ifdef MODULE
5745
5746 static char         *mode = NULL;
5747 static int          vesa = -1;
5748 static unsigned int rate = 0;
5749 static unsigned int crt1off = 1;
5750 static unsigned int mem = 0;
5751 static char         *forcecrt2type = NULL;
5752 static int          forcecrt1 = -1;
5753 static int          pdc = -1;
5754 static int          pdc1 = -1;
5755 static int          noaccel = -1;
5756 static int          noypan  = -1;
5757 static int          nomax = -1;
5758 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
5759 static int          inverse = 0;
5760 #endif
5761 static int          userom = -1;
5762 static int          useoem = -1;
5763 static char         *tvstandard = NULL;
5764 static int          nocrt2rate = 0;
5765 static int          scalelcd = -1;
5766 static char         *specialtiming = NULL;
5767 static int          lvdshl = -1;
5768 static int          tvxposoffset = 0, tvyposoffset = 0;
5769 static int          filter = -1;
5770 #if !defined(__i386__) && !defined(__x86_64__)
5771 static int          resetcard = 0;
5772 static int          videoram = 0;
5773 #endif
5774
5775 MODULE_DESCRIPTION("SiS 300/540/630/730/315/550/65x/661/74x/330/760 framebuffer device driver");
5776 MODULE_LICENSE("GPL");
5777 MODULE_AUTHOR("Thomas Winischhofer <thomas@winischhofer.net>, Others");
5778
5779 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
5780 MODULE_PARM(mem, "i");
5781 MODULE_PARM(noaccel, "i");
5782 MODULE_PARM(noypan, "i");
5783 MODULE_PARM(nomax, "i");
5784 MODULE_PARM(userom, "i");
5785 MODULE_PARM(useoem, "i");
5786 MODULE_PARM(mode, "s");
5787 MODULE_PARM(vesa, "i");
5788 MODULE_PARM(rate, "i");
5789 MODULE_PARM(forcecrt1, "i");
5790 MODULE_PARM(forcecrt2type, "s");
5791 MODULE_PARM(scalelcd, "i");
5792 MODULE_PARM(pdc, "i");
5793 MODULE_PARM(pdc1, "i");
5794 MODULE_PARM(specialtiming, "s");
5795 MODULE_PARM(lvdshl, "i");
5796 MODULE_PARM(tvstandard, "s");
5797 MODULE_PARM(tvxposoffset, "i");
5798 MODULE_PARM(tvyposoffset, "i");
5799 MODULE_PARM(filter, "i");
5800 MODULE_PARM(nocrt2rate, "i");
5801 MODULE_PARM(inverse, "i");
5802 #if !defined(__i386__) && !defined(__x86_64__)
5803 MODULE_PARM(resetcard, "i");
5804 MODULE_PARM(videoram, "i");
5805 #endif
5806 #endif
5807
5808 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)
5809 module_param(mem, int, 0);
5810 module_param(noaccel, int, 0);
5811 module_param(noypan, int, 0);
5812 module_param(nomax, int, 0);
5813 module_param(userom, int, 0);
5814 module_param(useoem, int, 0);
5815 module_param(mode, charp, 0);
5816 module_param(vesa, int, 0);
5817 module_param(rate, int, 0);
5818 module_param(forcecrt1, int, 0);
5819 module_param(forcecrt2type, charp, 0);
5820 module_param(scalelcd, int, 0);
5821 module_param(pdc, int, 0);
5822 module_param(pdc1, int, 0);
5823 module_param(specialtiming, charp, 0);
5824 module_param(lvdshl, int, 0);
5825 module_param(tvstandard, charp, 0);
5826 module_param(tvxposoffset, int, 0);
5827 module_param(tvyposoffset, int, 0);
5828 module_param(filter, int, 0);
5829 module_param(nocrt2rate, int, 0);
5830 #if !defined(__i386__) && !defined(__x86_64__)
5831 module_param(resetcard, int, 0);
5832 module_param(videoram, int, 0);
5833 #endif
5834 #endif
5835
5836 MODULE_PARM_DESC(mem,
5837         "\nDetermines the beginning of the video memory heap in KB. This heap is used\n"
5838           "for video RAM management for eg. DRM/DRI. On 300 series, the default depends\n"
5839           "on the amount of video RAM available. If 8MB of video RAM or less is available,\n"
5840           "the heap starts at 4096KB, if between 8 and 16MB are available at 8192KB,\n"
5841           "otherwise at 12288KB. On 315 and Xabre series, the heap size is 32KB by default.\n"
5842           "The value is to be specified without 'KB' and must match the MaxXFBMem setting\n"
5843           "for XFree86 4.x/X.org 6.7 and later.\n");
5844
5845 MODULE_PARM_DESC(noaccel,
5846         "\nIf set to anything other than 0, 2D acceleration will be disabled.\n"
5847           "(default: 0)\n");
5848
5849 MODULE_PARM_DESC(noypan,
5850         "\nIf set to anything other than 0, y-panning will be disabled and scrolling\n"
5851           "will be performed by redrawing the screen. (default: 0)\n");
5852
5853 MODULE_PARM_DESC(nomax,
5854         "\nIf y-panning is enabled, sisfb will by default use the entire available video\n"
5855           "memory for the virtual screen in order to optimize scrolling performance. If\n"
5856           "this is set to anything other than 0, sisfb will not do this and thereby \n"
5857           "enable the user to positively specify a virtual Y size of the screen using\n"
5858           "fbset. (default: 0)\n");
5859
5860 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
5861 MODULE_PARM_DESC(mode,
5862         "\nSelects the desired display mode in the format [X]x[Y]x[Depth], eg.\n"
5863           "1024x768x16. Other formats supported include XxY-Depth and\n"
5864           "XxY-Depth@Rate. If the parameter is only one (decimal or hexadecimal)\n"
5865           "number, it will be interpreted as a VESA mode number. (default: none if\n"
5866           "sisfb is a module; this leaves the console untouched and the driver will\n"
5867           "only do the video memory management for eg. DRM/DRI; 800x600x8 if sisfb\n"
5868           "is in the kernel)\n");
5869 MODULE_PARM_DESC(vesa,
5870         "\nSelects the desired display mode by VESA defined mode number, eg. 0x117\n"
5871           "(default: 0x0000 if sisfb is a module; this leaves the console untouched\n"
5872           "and the driver will only do the video memory management for eg. DRM/DRI;\n"
5873           "0x0103 if sisfb is in the kernel)\n");
5874 #endif
5875
5876 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)
5877 MODULE_PARM_DESC(mode,
5878        "\nSelects the desired default display mode in the format XxYxDepth,\n"
5879          "eg. 1024x768x16. Other formats supported include XxY-Depth and\n"
5880          "XxY-Depth@Rate. If the parameter is only one (decimal or hexadecimal)\n"
5881          "number, it will be interpreted as a VESA mode number. (default: 800x600x8)\n");
5882
5883 MODULE_PARM_DESC(vesa,
5884        "\nSelects the desired default display mode by VESA defined mode number, eg.\n"
5885          "0x117 (default: 0x0103)\n");
5886 #endif
5887
5888 MODULE_PARM_DESC(rate,
5889         "\nSelects the desired vertical refresh rate for CRT1 (external VGA) in Hz.\n"
5890           "If the mode is specified in the format XxY-Depth@Rate, this parameter\n"
5891           "will be ignored (default: 60)\n");
5892
5893 MODULE_PARM_DESC(forcecrt1,
5894         "\nNormally, the driver autodetects whether or not CRT1 (external VGA) is \n"
5895           "connected. With this option, the detection can be overridden (1=CRT1 ON,\n"
5896           "0=CRT1 OFF) (default: [autodetected])\n");
5897
5898 MODULE_PARM_DESC(forcecrt2type,
5899         "\nIf this option is omitted, the driver autodetects CRT2 output devices, such as\n"
5900           "LCD, TV or secondary VGA. With this option, this autodetection can be\n"
5901           "overridden. Possible parameters are LCD, TV, VGA or NONE. NONE disables CRT2.\n"
5902           "On systems with a SiS video bridge, parameters SVIDEO, COMPOSITE or SCART can\n"
5903           "be used instead of TV to override the TV detection. Furthermore, on systems\n"
5904           "with a SiS video bridge, SVIDEO+COMPOSITE, HIVISION, YPBPR480I, YPBPR480P,\n"
5905           "YPBPR720P and YPBPR1080I are understood. However, whether or not these work\n"
5906           "depends on the very hardware in use. (default: [autodetected])\n");
5907
5908 MODULE_PARM_DESC(scalelcd,
5909         "\nSetting this to 1 will force the driver to scale the LCD image to the panel's\n"
5910           "native resolution. Setting it to 0 will disable scaling; LVDS panels will\n"
5911           "show black bars around the image, TMDS panels will probably do the scaling\n"
5912           "themselves. Default: 1 on LVDS panels, 0 on TMDS panels\n");
5913
5914 MODULE_PARM_DESC(pdc,
5915         "\nThis is for manually selecting the LCD panel delay compensation. The driver\n"
5916           "should detect this correctly in most cases; however, sometimes this is not\n"
5917           "possible. If you see 'small waves' on the LCD, try setting this to 4, 32 or 24\n"
5918           "on a 300 series chipset; 6 on a 315 series chipset. If the problem persists,\n"
5919           "try other values (on 300 series: between 4 and 60 in steps of 4; on 315 series:\n"
5920           "any value from 0 to 31). (default: autodetected, if LCD is active during start)\n");
5921
5922 #ifdef CONFIG_FB_SIS_315
5923 MODULE_PARM_DESC(pdc1,
5924         "\nThis is same as pdc, but for LCD-via CRT1. Hence, this is for the 315/330\n"
5925           "series only. (default: autodetected if LCD is in LCD-via-CRT1 mode during\n"
5926           "startup) - Note: currently, this has no effect because LCD-via-CRT1 is not\n"
5927           "implemented yet.\n");
5928 #endif
5929
5930 MODULE_PARM_DESC(specialtiming,
5931         "\nPlease refer to documentation for more information on this option.\n");
5932
5933 MODULE_PARM_DESC(lvdshl,
5934         "\nPlease refer to documentation for more information on this option.\n");
5935
5936 MODULE_PARM_DESC(tvstandard,
5937         "\nThis allows overriding the BIOS default for the TV standard. Valid choices are\n"
5938           "pal, ntsc, palm and paln. (default: [auto; pal or ntsc only])\n");
5939
5940 MODULE_PARM_DESC(tvxposoffset,
5941         "\nRelocate TV output horizontally. Possible parameters: -32 through 32.\n"
5942           "Default: 0\n");
5943
5944 MODULE_PARM_DESC(tvyposoffset,
5945         "\nRelocate TV output vertically. Possible parameters: -32 through 32.\n"
5946           "Default: 0\n");
5947
5948 MODULE_PARM_DESC(filter,
5949         "\nSelects TV flicker filter type (only for systems with a SiS301 video bridge).\n"
5950           "(Possible values 0-7, default: [no filter])\n");
5951
5952 MODULE_PARM_DESC(nocrt2rate,
5953         "\nSetting this to 1 will force the driver to use the default refresh rate for\n"
5954           "CRT2 if CRT2 type is VGA. (default: 0, use same rate as CRT1)\n");
5955
5956 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
5957 MODULE_PARM_DESC(inverse,
5958         "\nSetting this to anything but 0 should invert the display colors, but this\n"
5959           "does not seem to work. (default: 0)\n");
5960 #endif
5961
5962 #if !defined(__i386__) && !defined(__x86_64__)
5963 #ifdef CONFIG_FB_SIS_300
5964 MODULE_PARM_DESC(resetcard,
5965         "\nSet this to 1 in order to reset (POST) the card on non-x86 machines where\n"
5966           "the BIOS did not POST the card (only supported for SiS 300/305 currently).\n"
5967           "Default: 0\n");
5968
5969 MODULE_PARM_DESC(videoram,
5970         "\nSet this to the amount of video RAM (in kilobyte) the card has. Required on\n"
5971           "some non-x86 architectures where the memory auto detection fails. Only\n"
5972           "relevant if resetcard is set, too. Default: [auto-detect]\n");
5973 #endif
5974 #endif
5975
5976 int __init sisfb_init_module(void)
5977 {
5978         sisfb_setdefaultparms();
5979
5980         if(rate) sisfb_parm_rate = rate;
5981
5982         if((scalelcd == 0) || (scalelcd == 1)) {
5983            sisfb_scalelcd = scalelcd ^ 1;
5984         }
5985
5986         /* Need to check crt2 type first for fstn/dstn */
5987
5988         if(forcecrt2type)
5989                 sisfb_search_crt2type(forcecrt2type);
5990
5991         if(tvstandard)
5992                 sisfb_search_tvstd(tvstandard);
5993
5994         if(mode)
5995                 sisfb_search_mode(mode, FALSE);
5996         else if(vesa != -1)
5997                 sisfb_search_vesamode(vesa, FALSE);
5998
5999         sisfb_crt1off = (crt1off == 0) ? 1 : 0;
6000
6001         sisfb_forcecrt1 = forcecrt1;
6002         if(forcecrt1 == 1)      sisfb_crt1off = 0;
6003         else if(forcecrt1 == 0) sisfb_crt1off = 1;
6004
6005         if(noaccel == 1)      sisfb_accel = 0;
6006         else if(noaccel == 0) sisfb_accel = 1;
6007
6008         if(noypan == 1)       sisfb_ypan = 0;
6009         else if(noypan == 0)  sisfb_ypan = 1;
6010
6011         if(nomax == 1)        sisfb_max = 0;
6012         else if(nomax == 0)   sisfb_max = 1;
6013
6014 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
6015         if(inverse)           sisfb_inverse = 1;
6016 #endif
6017
6018         if(mem)               sisfb_parm_mem = mem;
6019
6020         if(userom != -1)      sisfb_userom = userom;
6021         if(useoem != -1)      sisfb_useoem = useoem;
6022
6023         if(pdc != -1)  sisfb_pdc  = (pdc  & 0x7f);
6024         if(pdc1 != -1) sisfb_pdca = (pdc1 & 0x1f);
6025
6026         sisfb_nocrt2rate = nocrt2rate;
6027
6028         if(specialtiming)
6029                 sisfb_search_specialtiming(specialtiming);
6030
6031         if((lvdshl >= 0) && (lvdshl <= 3))  sisfb_lvdshl = lvdshl;
6032
6033         if(filter != -1) sisfb_filter = filter;
6034
6035         sisfb_tvxposoffset = tvxposoffset;
6036         sisfb_tvyposoffset = tvyposoffset;
6037
6038 #if !defined(__i386__) && !defined(__x86_64__)
6039         sisfb_resetcard = (resetcard) ? 1 : 0;
6040         if(videoram)    sisfb_videoram = videoram;
6041 #endif
6042
6043         return(sisfb_init());
6044 }
6045
6046 static void __exit sisfb_remove_module(void)
6047 {
6048         pci_unregister_driver(&sisfb_driver);
6049         printk(KERN_DEBUG "sisfb: Module unloaded\n");
6050 }
6051
6052 module_init(sisfb_init_module);
6053 module_exit(sisfb_remove_module);
6054
6055 #endif     /*  /MODULE  */
6056
6057 EXPORT_SYMBOL(sis_malloc);
6058 EXPORT_SYMBOL(sis_free);
6059
6060