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