drivers/video/fbdev/sis/sis_main.c

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