drivers/video/sis/sis_main.c

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