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